Clavier matriciel

tiotjordan · December 3, 2017, 8:08pm

Bonjour a tous,

Alors voila, j'ai réalisé mon automate pour terrarium, tous fonctionne impeccable. Un ami éleveur serait intéresser par un tel système pour son élevage, mais avec la possibilité de régler les températures via un clavier matriciel (sa, c'est mon idée, lui n'y connait absolument rien).

Ma question est la suivante (j'ai chercher mais rien trouver de concluant sur internet( : comment faire pour qu'il puisse régler la température voulu sur arduino a l'aide d'un clavier matriciel.

Je sais faire le code pour la gestion des relais,... en fonction du temps (via RTC), ... , mais je ne sais pas comment me servir du clavier et sur internet je ne trouve pas ce que je veux.

En sachant que l'automate gérera plusieurs terrariums (genre un appui sur * fait défiler les différents terrariums et la affichage du N° de terra sur une ligne, de la température réelle et de la température de consigne, que je veut pouvoir modifier via le clavier.

En vous remerciant.

Cordialement.

J-M-L · December 3, 2017, 8:38pm

j'ai chercher mais rien trouver de concluant sur internet

sérieux?

[url=https://playground.arduino.cc/Code/Keypad]Arduino Keypad[/url] n'a rien donné ? Google est cassé chez vous ?

tiotjordan · December 3, 2017, 9:12pm

Si, j'ai bien vu ceci, or, je ne vois pas comment faire pour modifier une valeur dans mon programme directement avec le keypad, avec le choix du terrarium concerné, ...

Je ne demande pas que l'on me donne la réponse tel quel, je voudrais juste que l'on m'aiguille.

J-M-L · December 3, 2017, 9:19pm

vous "écoutez" le keypad à chaque tour de boucle, s'il est appuyé vous accumulez les touches reçues dans un petit buffer, quand la touche de confirmation (# par exemple) et reçue alors vous faites quelque chose en fonction de ce qui est dans le buffer. si j'appuie directement sur * vous passez a terrarium suivant

vous pouvez jetez un oeil à mon petit tuto général sur les flux asynchrones

ça devrait vous aider

tiotjordan · December 3, 2017, 9:44pm

Mouais, c'est assez complexe quand même, ou alors je ne comprend pas tous...

En fait, dans ma tête, sa a l'air assez simple, mais la mise en oeuvre, oulala.....

J-M-L · December 4, 2017, 3:46am

Votre code sait il gérer plusieurs terrarium?

Mon tuto a le code qui fait ce que vous voulez - analysez le denier exemple avec le mot de passe - le code test si on a reçu un appui - si oui ça la gère ensuite vous pouvez avoir votre code habituel de terrarium à condition bien sûr qu’un tour de loop() ne prenne pas trop longtemps - quelques ms au Max - sinon vous ne reviendrez pas assez souvent pour lire le clavier (ou alors il faut gérer le clavier par interruptions et c’est un peu plus complexe)

Allez aussi lire mon tuto sur les machines à état qui est référencé dans ce tuto. Ça vous aidera à comprendre comment on crée une architecture propre d’un code qui attend des événements

tiotjordan · December 4, 2017, 5:46am

Ok, je regarderais tous sa dans la journée.

Oui, le code devra gérer plusieurs terrariums (le maximum possible), pour commander des relais en fonction de la température demander et des relais pour l'allumage des lumières (la modification de ces valeurs n'as pas d'importance).

J-M-L · December 4, 2017, 6:56am

Il va donc falloir restructurer votre code - définir “proprement” sans doute une structure terrarium dans laquelle vous allez stocker les éléments pertinents pour chaque terrarium (pins de controle, paramètres cibles et timing et relevé des valeurs courantes).

Ensuite vous créez un tableau de ces structures avec une entrée par terrarium à gérer, et initialisez ce qui doit / peut l’être au départ. Vous devez avoir deux variables index dans ce tableau - une pour celui dont vous affichez les infos sur le LCD (lcdIndex) une pour celui que vous devez « vérifier » (auditIndex)

La boucle principale doit

écouter le clavier et éventuellement traiter un ordre reçu si la commande est complète en modifiant les données du terrarium en lcdIndex et mise à jour de l’afficheur
aller voir comment se comporte le terrarium en auditIndex, mettre à jour les valeurs dans la structure et prendre les décisions nécessaires sur ses relais
si auditIndex est égal à lcdIndex alors modifier l’affichage avec les nouvelles valeurs relevées
passer auditIndex au terrarium suivant (en revenant à 0 si vous êtes au bout du tableau)
retourner au début de boucle.

Ne traitez pas tous les terrarium au sein d’une même loop() sinon vous ne reviendrez pas tester assez souvent le clavier

Le traitement d’un terrarium correspondant à ce que vous faites actuellement - mettre ce code dans une fonction ne devrait pas être compliqué

je vous suggère aussi de travailler en asynchrone pour les lectures de Températures pour ne pas bloquer pendant plusieurs centaines de ms la loop() sinon vous allez rater les appuis clavier

(Vous pouvez aller voir éventuellement comment je traite cela : dans les projets finis j’ai posté un code «Contrôleur de T°, Humidité avec pilotage manuel ou automatique » qui lit en décalé les capteurs de températures)

tiotjordan · December 4, 2017, 12:34pm

Bonjour,

Vous m’avez l’air vachement callé là dessus.

Je vais commencer par créer mon programme de base sans le clavier (que j’ai commander de matin je n’en avais pas, j’ai pris un clavier avec touche F1/F2/enter/escape en plus des chiffres).

Auriez vous, par hasard, un exemple de code qui modifierais les valeurs d’un programme en fonction de ce que l’on tape sur le clavier ? Je dois avouer que je suis un peu perdu la, j’ai lu vos liens, mais sa m’a l’air plus complexe que je ne le pensais.

En vous remerciant.

Cordialement.

tiotjordan · December 4, 2017, 7:53pm

Bonsoir,

Donc voila ou j'en suis pour l'instant, a savoir la partie setup

    #include <Key.h>
#include <Keypad.h>
#include <LiquidCrystal_I2C.h> //Inclus la librairie LiquidCrystal I2C
#include <RTClib.h> //Inclus la librairie RTC
#include <Wire.h> //Inclus la librairie Wire
//#include <DallasTemperature.h> //Inclus la librairie DallasTemperature (capteur DS18B20)

RTC_DS1307 RTC; //Classe RTC_DS1307

//Déclaration des sondes de température DS18B20

const int SONDE_TERRA_1 = 1;
const int SONDE_TERRA_2 = 2;
const int SONDE_TERRA_3 = 3;
const int SONDE_TERRA_4 = 4;
const int SONDE_TERRA_5 = 5;
const int SONDE_TERRA_6 = 6;
const int SONDE_TERRA_7 = 7;
const int SONDE_TERRA_8 = 8;
const int SONDE_TERRA_9 = 9;
const int SONDE_TERRA_10 = 10;
const int SONDE_TERRA_11 = 11;
const int SONDE_TERRA_12 = 12;
const int SONDE_TERRA_13 = 13;
const int SONDE_TERRA_14 = 14;

//Déclaration des relais de tapis chauffants

const int RELAIS_TAPIS_TERRA_1 = 15;
const int RELAIS_TAPIS_TERRA_2 = 16;
const int RELAIS_TAPIS_TERRA_3 = 17;
const int RELAIS_TAPIS_TERRA_4 = 18;
const int RELAIS_TAPIS_TERRA_5 = 19;
const int RELAIS_TAPIS_TERRA_6 = 22;
const int RELAIS_TAPIS_TERRA_7 = 23;
const int RELAIS_TAPIS_TERRA_8 = 24;
const int RELAIS_TAPIS_TERRA_9 = 25;
const int RELAIS_TAPIS_TERRA_10 = 26;
const int RELAIS_TAPIS_TERRA_11 = 27;
const int RELAIS_TAPIS_TERRA_12 = 28;
const int RELAIS_TAPIS_TERRA_13 = 29;
const int RELAIS_TAPIS_TERRA_14 = 30;

//Déclaration des relais d'éclairage

const int RELAIS_ECLAIRAGE_TERRA_1 = 31;
const int RELAIS_ECLAIRAGE_TERRA_2 = 32;
const int RELAIS_ECLAIRAGE_TERRA_3 = 33;
const int RELAIS_ECLAIRAGE_TERRA_4 = 34;
const int RELAIS_ECLAIRAGE_TERRA_5 = 35;
const int RELAIS_ECLAIRAGE_TERRA_6 = 36;
const int RELAIS_ECLAIRAGE_TERRA_7 = 37;
const int RELAIS_ECLAIRAGE_TERRA_8 = 38;
const int RELAIS_ECLAIRAGE_TERRA_9 = 39;
const int RELAIS_ECLAIRAGE_TERRA_10 = 40;
const int RELAIS_ECLAIRAGE_TERRA_11 = 41;
const int RELAIS_ECLAIRAGE_TERRA_12 = 42;
const int RELAIS_ECLAIRAGE_TERRA_13 = 43;
const int RELAIS_ECLAIRAGE_TERRA_14 = 44;

LiquidCrystal_I2C lcd(0x27, 20, 4);
//LiquidCrystal_I2C lcd(0x3F,20,4);

const byte ROWS = 5; //nombre de lignes
const byte COLS = 4; //nombre de colonnes

char keys[ROWS][COLS] = {
  {'F1', 'F2', '#', '*'},
  {'1', '2', '3', 'U'},
  {'4', '5', '6', 'D'},
  {'7', '8', '9', 'ES'},
  {'L', '0', 'R', 'ENT'}

};

//byte rowPins[ROWS] = {45, 46, 47, 48, 49}; //entrées numériques où sont branchées les lignes
//byte colPins[COLS] = {50, 51, 52, 53}; //entrées numériques où sont branchées les colonnes

//Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup() {


  Serial.begin(57600); //Démarrage de la communication serie a 57600 bauds
  Wire.begin(); //Démarrage de la librairie Wire
  RTC.begin(); //Démarrage de la librairie RTC
  //RTC.adjust(DateTime(__DATE__, __TIME__)); //Mise a l'heure du module RTC à l'heure de téléversement du programme

  lcd.init();

  //Déclaration des entrées sondes DS18B20

  pinMode (SONDE_TERRA_1, INPUT);
  pinMode (SONDE_TERRA_2, INPUT);
  pinMode (SONDE_TERRA_3, INPUT);
  pinMode (SONDE_TERRA_4, INPUT);
  pinMode (SONDE_TERRA_5, INPUT);
  pinMode (SONDE_TERRA_6, INPUT);
  pinMode (SONDE_TERRA_7, INPUT);
  pinMode (SONDE_TERRA_8, INPUT);
  pinMode (SONDE_TERRA_9, INPUT);
  pinMode (SONDE_TERRA_10, INPUT);
  pinMode (SONDE_TERRA_11, INPUT);
  pinMode (SONDE_TERRA_12, INPUT);
  pinMode (SONDE_TERRA_13, INPUT);
  pinMode (SONDE_TERRA_14, INPUT);

  digitalWrite (SONDE_TERRA_1, LOW);
  digitalWrite (SONDE_TERRA_2, LOW);
  digitalWrite (SONDE_TERRA_3, LOW);
  digitalWrite (SONDE_TERRA_4, LOW);
  digitalWrite (SONDE_TERRA_5, LOW);
  digitalWrite (SONDE_TERRA_6, LOW);
  digitalWrite (SONDE_TERRA_7, LOW);
  digitalWrite (SONDE_TERRA_8, LOW);
  digitalWrite (SONDE_TERRA_9, LOW);
  digitalWrite (SONDE_TERRA_10, LOW);
  digitalWrite (SONDE_TERRA_11, LOW);
  digitalWrite (SONDE_TERRA_12, LOW);
  digitalWrite (SONDE_TERRA_13, LOW);
  digitalWrite (SONDE_TERRA_14, LOW);

  //Déclaration des sorties relais tapis chauffants

  pinMode (RELAIS_TAPIS_TERRA_1, OUTPUT);
  pinMode (RELAIS_TAPIS_TERRA_2, OUTPUT);
  pinMode (RELAIS_TAPIS_TERRA_3, OUTPUT);
  pinMode (RELAIS_TAPIS_TERRA_4, OUTPUT);
  pinMode (RELAIS_TAPIS_TERRA_5, OUTPUT);
  pinMode (RELAIS_TAPIS_TERRA_6, OUTPUT);
  pinMode (RELAIS_TAPIS_TERRA_7, OUTPUT);
  pinMode (RELAIS_TAPIS_TERRA_8, OUTPUT);
  pinMode (RELAIS_TAPIS_TERRA_9, OUTPUT);
  pinMode (RELAIS_TAPIS_TERRA_10, OUTPUT);
  pinMode (RELAIS_TAPIS_TERRA_11, OUTPUT);
  pinMode (RELAIS_TAPIS_TERRA_12, OUTPUT);
  pinMode (RELAIS_TAPIS_TERRA_13, OUTPUT);
  pinMode (RELAIS_TAPIS_TERRA_14, OUTPUT);

  digitalWrite (RELAIS_TAPIS_TERRA_1, LOW);
  digitalWrite (RELAIS_TAPIS_TERRA_2, LOW);
  digitalWrite (RELAIS_TAPIS_TERRA_3, LOW);
  digitalWrite (RELAIS_TAPIS_TERRA_4, LOW);
  digitalWrite (RELAIS_TAPIS_TERRA_5, LOW);
  digitalWrite (RELAIS_TAPIS_TERRA_6, LOW);
  digitalWrite (RELAIS_TAPIS_TERRA_7, LOW);
  digitalWrite (RELAIS_TAPIS_TERRA_8, LOW);
  digitalWrite (RELAIS_TAPIS_TERRA_9, LOW);
  digitalWrite (RELAIS_TAPIS_TERRA_10, LOW);
  digitalWrite (RELAIS_TAPIS_TERRA_11, LOW);
  digitalWrite (RELAIS_TAPIS_TERRA_12, LOW);
  digitalWrite (RELAIS_TAPIS_TERRA_13, LOW);
  digitalWrite (RELAIS_TAPIS_TERRA_14, LOW);

  //Déclaration des sorties éclairage

  pinMode (RELAIS_ECLAIRAGE_TERRA_1, OUTPUT);
  pinMode (RELAIS_ECLAIRAGE_TERRA_2, OUTPUT);
  pinMode (RELAIS_ECLAIRAGE_TERRA_3, OUTPUT);
  pinMode (RELAIS_ECLAIRAGE_TERRA_4, OUTPUT);
  pinMode (RELAIS_ECLAIRAGE_TERRA_5, OUTPUT);
  pinMode (RELAIS_ECLAIRAGE_TERRA_6, OUTPUT);
  pinMode (RELAIS_ECLAIRAGE_TERRA_7, OUTPUT);
  pinMode (RELAIS_ECLAIRAGE_TERRA_8, OUTPUT);
  pinMode (RELAIS_ECLAIRAGE_TERRA_9, OUTPUT);
  pinMode (RELAIS_ECLAIRAGE_TERRA_10, OUTPUT);
  pinMode (RELAIS_ECLAIRAGE_TERRA_11, OUTPUT);
  pinMode (RELAIS_ECLAIRAGE_TERRA_12, OUTPUT);
  pinMode (RELAIS_ECLAIRAGE_TERRA_13, OUTPUT);
  pinMode (RELAIS_ECLAIRAGE_TERRA_14, OUTPUT);

  digitalWrite (RELAIS_ECLAIRAGE_TERRA_1, LOW);
  digitalWrite (RELAIS_ECLAIRAGE_TERRA_2, LOW);
  digitalWrite (RELAIS_ECLAIRAGE_TERRA_3, LOW);
  digitalWrite (RELAIS_ECLAIRAGE_TERRA_4, LOW);
  digitalWrite (RELAIS_ECLAIRAGE_TERRA_5, LOW);
  digitalWrite (RELAIS_ECLAIRAGE_TERRA_6, LOW);
  digitalWrite (RELAIS_ECLAIRAGE_TERRA_7, LOW);
  digitalWrite (RELAIS_ECLAIRAGE_TERRA_8, LOW);
  digitalWrite (RELAIS_ECLAIRAGE_TERRA_9, LOW);
  digitalWrite (RELAIS_ECLAIRAGE_TERRA_10, LOW);
  digitalWrite (RELAIS_ECLAIRAGE_TERRA_11, LOW);
  digitalWrite (RELAIS_ECLAIRAGE_TERRA_12, LOW);
  digitalWrite (RELAIS_ECLAIRAGE_TERRA_13, LOW);
  digitalWrite (RELAIS_ECLAIRAGE_TERRA_14, LOW);

}

void loop() {

  DateTime now = RTC.now();
  //Serial.print(now.day(), DEC);
  //Serial.print('/');
  //Serial.print(now.month(), DEC);
  //Serial.print('/');
  //Serial.print(now.year(), DEC);
  //Serial.print(' ');
  //Serial.print(now.hour(), DEC);
  //Serial.print(':');
  //Serial.print(now.minute(), DEC);
  //Serial.print(':');
  //Serial.print(now.second(), DEC);
  //Serial.println();
  //delay(1000);
   
    }

J-M-L · December 4, 2017, 8:29pm

Ca compile?(à mon avis non à cause de

const int SONDE_TERRA_3=2;
    const int SONDE_TERRA_3=3;

(et les pins sont mieux en const byte)

Votre code va être totalement « bordélique » - utilisez des tableaux!

tiotjordan · December 4, 2017, 8:37pm

Donc, je doit remplacer const int par const byte, OK.

Je ne vois pas comment utiliser des tableaux, ou du moins, je ne comprend pas trop...

J-M-L · December 4, 2017, 8:58pm

un truc comme cela (j'en ai déclaré que 5 ici mais le principe est le même pour 14)

struct terrarium_t {
  byte pinSonde;
  byte pinRelaisTapis;
  byte pinRelaisEclairage;
  int temperature;
};

terrarium_t terrarium[] = {
  {1, 15, 31, 0},
  {2, 16, 32, 0},
  {3, 17, 33, 0},
  {4, 18, 34, 0},
  {5, 19, 35, 0}
};

const byte nombreDeTerrarium = sizeof(terrarium) / sizeof(terrarium[0]);

void setup() {
  Serial.begin(115200);
  for (byte i = 0; i < nombreDeTerrarium; i++) {
    pinMode (terrarium[i].pinSonde, INPUT); //Déclaration des entrées sondes DS18B20
    pinMode (terrarium[i].pinRelaisTapis, OUTPUT); //Déclaration des sorties relais tapis chauffants
    digitalWrite (terrarium[i].pinRelaisTapis, LOW);
    pinMode (terrarium[i].pinRelaisEclairage, OUTPUT); //Déclaration des sorties éclairage
    digitalWrite (terrarium[i].pinRelaisEclairage, LOW);
  }
}

void loop() {}

c'est plus court non?

corrigez votre post ci dessus et rajoutez les code tags autour du code:
[code]`` [color=blue]// votre code ici[/color] ``[/code].

ça doit ressembler à cela:// votre code ici
(faites aussi ctrl-T (PC) or cmd-T (Mac) dans l'IDE avant de copier le code pour qu'il soit indenté correctement)

tiotjordan · December 4, 2017, 9:11pm

C'est modifier pour le code.

Oui en effet, c'est beaucoup plus court.

Je vous remercie de prendre le temps de m'aider parce que la, sa se complique, mais avec un exemple concret, je visualise déjà plus facilement (et une fois fait une fois, les prochains programmes seront plus simples a faire, c'est en forgeant que l'on devient forgeron).

Donc, je vais modifier mon code comme vous me lavez expliquer pour toutes les déclarations et les 14 terrariums.

Mais pour ce qui est du clavier matriciel, comment l'inclure ? J'ai vu pas mal de chose sur internet, mais aucun exemple qui montre ce que je vais faire, et duquel je pourrais m'inspirer.

En vous remerciant.

J-M-L · December 4, 2017, 9:12pm

pour l'exemple du keypad, si vous regardez dans mon tuto le dernier bout de code

#include <Keypad.h>

const byte ROWS = 4; //4 rangées
const byte COLS = 4; //4 colonnes

char keys[ROWS][COLS] = {   //les symboles, déclarés par leur code ASCII dans le tableau à 2 dimension
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

byte rowPins[ROWS] = { 34, 36, 38, 40 }; // On connecte ROW0, ROW1, ROW2 and ROW3 à ces pins (je suis sur un MEGA)
byte colPins[COLS] = {41, 39, 37, 35}; // On connecte  COL0, COL1, COL2 and COL3 à ces pins (je suis sur un MEGA)

Keypad membraneKeypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS);  //On initialise une instance de la classe Keypad

const byte tailleMessageMax = 50;
char message[tailleMessageMax + 1]; // +1 car on doit avoir un caractère de fin de chaîne en C, le '\0'

const char marqueurDeFin = '#';
const char motDePasse[] = "1221";

boolean ecouter()
{
  static byte indexMessage = 0; // static pour se souvenir de cette variable entre 2 appels consécutifs. initialisée qu'une seule fois.
  boolean messageEnCours = true;

  char c = membraneKeypad.getKey();
  if (c != NO_KEY) {
    if (c == marqueurDeFin) {
      message[indexMessage] = '\0'; // on termine la c-string
      indexMessage = 0; // on se remet au début pour la prochaine fois
      messageEnCours = false;
    } else if (indexMessage <= tailleMessageMax - 1) message[indexMessage++] = (char) c; // on stocke le caractère et on passe à la case suivante
  }
  return messageEnCours;
}

void setup() {
  Serial.begin(115200);
}
void loop() {
  if (! ecouter()) {
    if (!strcmp(message, motDePasse)) {
      Serial.println(F("Mot de passe correct"));
    } else {
      Serial.println(F("la police est en route"));
    }
  }
  // ici on peut faire autre chose
}

la fonction ecouter() construit dans un petit tableau message la suite de toutes les touches appuyées (jusqu'à ce qu'il n'y est plus de place, ici limité à 50).

La fonction retourne vrai si le message est en Cours et faux quand vous tapez le marqueurDeFin (la touche #)

c'est pour cela que la boucle appelle sans cesse if (! ecouter()) {

Quand vous avez tapé # alors on rentre dans le if et je fais une comparaison en utilisant la fonction strcmp() avec le contenu du message reçu et la chaîne motDePasse. Si les 2 sont identiques alors j'affiche que vous avez trouvé le bon mot de passe, sinon "la police est en route"

Dans votre code au lieu de faire un affichage vous pourriez lire le texte tapé pour le convertir en un entier (soit à la volée, soit avec atoi()) et affecter cela à la consigne (à rajouter dans la structure bien sûr) du terrarium selectionné pour l'affichage

strcmp() est une fonction de comparaison de deux chaines de caractères et atoi() transforme une chaîne en nombre --> vous trouverez plus d'infos dans ces bibliothèques standard sur les fonctions existantes stdlib.h et string.h

tiotjordan · December 4, 2017, 9:39pm

Donc, si j'ai bien compris, voici le code pour le moment

#include <Key.h>
#include <Keypad.h>

struct terrarium_t {
  byte pinSonde;
  byte pinRelaisTapis;
  byte pinRelaisEclairage;
  int temperature;
};

const byte ROWS = 5; //4 rangées
const byte COLS = 4; //4 colonnes

char keys[ROWS][COLS] = {
  {'F1', 'F2', '#', '*'},
  {'1', '2', '3', 'U'},
  {'4', '5', '6', 'D'},
  {'7', '8', '9', 'ESC'}
  {'L', '0', 'R', 'ENT'}
};

byte rowPins[ROWS] = { 45, 46, 47, 48, 49 };
byte colPins[COLS] = {50, 51, 52, 53};

Keypad membraneKeypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS);

const byte tailleMessageMax = 2;
char message[tailleMessageMax + 1];

const char marqueurDeFin = 'ENT';

boolean ecouter()
{
  static byte indexMessage = 0;
  boolean messageEnCours = true;

  char c = membraneKeypad.getKey();
  if (c != NO_KEY) {
    if (c == marqueurDeFin) {
      message[indexMessage] = '\0';
      indexMessage = 0;
      messageEnCours = false;
    } else if (indexMessage <= tailleMessageMax - 1) message[indexMessage++] = (char) c;
  }
  return messageEnCours;
}


terrarium_t terrarium[] = {
  {1, 15, 31, 0},
  {2, 16, 32, 0},
  {3, 17, 33, 0},
  {4, 18, 34, 0},
  {5, 19, 35, 0}
  {6, 22, 36, 0},
  {7, 23, 37, 0},
  {8, 24, 38, 0},
  {9, 25, 39, 0},
  {10, 26, 40, 0},
  {11, 27, 41, 0},
  {12, 28, 42, 0},
  {13, 29, 43, 0},
  {14, 30, 44, 0},
};

const byte nombreDeTerrarium = sizeof(terrarium) / sizeof(terrarium[0]);

void setup() {

  Serial.begin(115200);
  for (byte i = 0; i < nombreDeTerrarium; i++) {
    pinMode (terrarium[i].pinSonde, INPUT); //Déclaration des entrées sondes DS18B20
    pinMode (terrarium[i].pinRelaisTapis, OUTPUT); //Déclaration des sorties relais tapis chauffants
    digitalWrite (terrarium[i].pinRelaisTapis, LOW);
    pinMode (terrarium[i].pinRelaisEclairage, OUTPUT); //Déclaration des sorties éclairage
    digitalWrite (terrarium[i].pinRelaisEclairage, LOW);
  }
}

void loop() {}

Donc, si je comprend a peu près, il faudrais faire un truc du genre

lcd.setCursor(3, 0);

if (c == 1) {
lcd.print("TERRARIUM 1");
lcd.setCursor(0, 1);
lcd.print("Temp. réelle");
lcd.print(" ");
lcd.print("valeur DS18B20");
lcd.setCursor(0, 2);
lcd.print("Temp. consigne");
lcd.print(" ");
 .....

Mais la, une fois taper tous sa, je me dit qu'il y a peut être moyen de faire sa avec un tableau, non ?

J-M-L · December 4, 2017, 9:44pm

Mais la, une fois taper tous sa, je me dit qu'il y a peut être moyen de faire sa avec un tableau, non ?

ben oui

tiotjordan · December 4, 2017, 10:01pm

Euhhhhhhhh..... la honnêtement je suis pommé......

J-M-L · December 4, 2017, 10:04pm

tiotjordan:
Euhhhhhhhh..... la honnêtement je suis pommé......

Euhhhhhhhh .....

vous savez m'expliquer ce que cela fait?

  for (byte i = 0; i < nombreDeTerrarium; i++) {
    pinMode (terrarium[i].pinSonde, INPUT); //Déclaration des entrées sondes DS18B20
    pinMode (terrarium[i].pinRelaisTapis, OUTPUT); //Déclaration des sorties relais tapis chauffants
    digitalWrite (terrarium[i].pinRelaisTapis, LOW);
    pinMode (terrarium[i].pinRelaisEclairage, OUTPUT); //Déclaration des sorties éclairage
    digitalWrite (terrarium[i].pinRelaisEclairage, LOW);
  }

Si non ça veut dire qu'il faut mettre le projet de côté et aller étudier les tableaux, les boucles, etc... les bases du langage C...

faites un cours OpenClassroom en C ou tout autre...

Si vous ne maitrisez pas le langage, vous ne ferez rien de bien...

tiotjordan · December 5, 2017, 5:41am

La première ligne, je ne peut pas vous dire, honnêtement, je vois a peu près ce que cela doit faire, mais de la a l'expliquer...
La suivante déclare les pinSonde comme entrées numériques
La suivante les pinRelaisTapis comme sorties numériques
La suivante met les pinRelaisTapis a l'état bas
La suivante déclare les pinRelaisEclairage comme sorties numériques
Et enfin la dernière déclare les pinRelaisEclairage a l'état bas

Je gère déjà mon propre terrarium tropical via arduino (gestion de la brumisation (mise en route a des heures précises pendant X secondes via un module RTC), fogger (machine a brume, mode de fonctionnement idem), mon chauffage (via une sonde DHT22 placé dans le terra), le tous avec un affichage sur écran LCD 16x2 de la date, heure sur la première ligne et température/humidité réelle sur la deuxième. J'ai également un capteur de niveau dans ma cuve, qui désactive la pompe s'il n'y a plus d'eau (pour éviter de la détériorer). Si plus d'eau, la LED RGB sur mon boitier passe du vert au rouge, et la pompe ne se déclenche plus, même en manuel (j'ai quand même mis en parallèle de mon programme "automatique" des boutons poussoirs pour pouvoir déclencher des cycles manuels).
Et pour finir, j'ai également une LED bleue qui indique quand la sortie tapis chauffant est active.

Donc, en sorte, du code "simple" (surement en le voyant me diriez vous il y a plus simple avec des tableaux, ...), que j'ai écrit en regardant des exemples sur internet, et via un ou deux conseils sur le forum.

Je suis totalement autodidacte la dessus.

Pour mon propre terra, je vais passer sur domoticz via raspberry pi avec des modules ESP 8266 (Sonoff si vous voyais), pour pouvoir tous piloter de n'importe ou.

Mais mon ami éleveur souhaiterais plus la solution arduino pour le moment, et sa me plait de voir comment pourrais être programmer une telle chose, et, dans la mesure du possible, lui programmer.

Comme je vous l'ai déjà dis, je suis du genre a savoir refaire ce que j'ai vu une fois, une fois que j'aurais réussi a obtenir du concret, sa sera beaucoup plus simple pour moi.

Topic		Replies	Views
Creation d'un système automatise pour terrarium Français	11	5822	May 6, 2021
[projet] automate terrarium tropical Français	27	2600	May 6, 2021
Help! Terrarium automatisé qui freeze Le bar	8	1592	May 7, 2021
Automatiser un terrarium tropical Français	46	17875	May 6, 2021
Clavier matriciel .... probleme de colonne et ligne Français	2	1113	May 6, 2021

Clavier matriciel

Related topics