Bonjour, la question va peu être vous paraitre étonnante mais est ce la bonne façon d'écrire cette fonction?
Je trouve cela très simpliste comparé au divers exemple que j'ai pu trouver.
if (millis() - previousTempsMillis >= 5000) {
previousTempsMillis = millis();
Serial.print("Tension: ");
Serial.println(Uef);
Serial.print("Courant: ");
Serial.println(Ief);
Serial.print("Puissance: ");
Serial.println(PW);
hello
oui, c'est ok
tu vas écrire toutes les 5 secondes sur le moniteur
if ((millis() - previousTempsMillis) >= 5000) {
previousTempsMillis = millis();
Serial.print(F("Tension: "));
Serial.println(Uef);
Serial.print(F("Courant: "));
Serial.println(Ief);
Serial.print(F("Puissance: "));
Serial.println(PW);
}
previousTempsMillis à été déclaré en unsigned long.
Est ce que tu pourrais retranscrire avec des mots cette fonction?
Par exemple: Si ......
au debut du programme
unsigned long previousTempsMillis = 0;
au debut du programme, le compteur Millis() commence à compter
arrivé dans la loop,
if ((millis() - previousTempsMillis) >= 5000)
si (le compteur Millis() - le temps noté au départ) est plus grand que 5000,
on exécute ce qui est contenu entre les accolades (ligne 2 à ligne 9)
et la premiere ligne qu'on y trouve, remet le temps noté au gout du jour.
donc au prochan passage, la soustraction sera largement inférieure à 5000
disons 4980 si la loop mets 20 ms à s'exécuter.
la condition n'étant pas vérifiée, on n'entre pas dans les accolades
et 251 loop après, le resultat de la soustraction est supérieur à 5000
on entre dans les accolades puisque la condition est remplie
et on remet la mémorisation previous temps au gout du jour
et ainsi de suite...
nota : 5000 = 5000 millisecondes soit 5 secondes
J'ai parfaitement compris, merci 
D'une manière générale, un programme est lu du haut vers le bas, nous sommes d'accord?
Tous ce qui ce trouve entre la première ligne et void loop() est lu une seul fois et ensuite le void loop() est lu en boucle à l'infini.
Est ce que toute cette première partie à une importance dans l'ordre dans laquelle c'est écrit?
const int buttonPin = 2;
const int ledPin = 13;
int buttonState = 0;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT);
}
void loop() {
buttonState = digitalRead(buttonPin);
if (buttonState == HIGH) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
}
nous avons tous notre façon de coder
en principe, je commence par déclarer les librairies, puis les capteurs et actionneurs
ensuite les variables ( nota: les variables déclarées à cet endroit auront une portée "globale" ( connue dans tout le programme) contrairement aux variables déclarées dans les fonctions qui ne sont connues que de la fonction dans laquelle elles ont été déclarées ( portée dite "locale").
je programme en "onglets"
pour exemple, voici l'onglet des initialisations d'un prog sur lequel je travaille en ce moment
// prendre une méga pour avoir des interruptions supplémentaires
//compteuse_4_6_V1
#define version 1
#include "interruptions.h"
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);
// les INT
const byte capteur_presence_flacons = 2;//interruption INT 0
const byte capteur_absence_flacons = 3;//interruption INT 1
const byte BP_arret_urgence = 18;//interruption INT 5
const byte BP_reset_pause = 19;//court=pause long=reset INT 4
//les entrées
const byte FDC_Repos_6 = 4;//fdc verin 6 rentré
const byte FDC_Travail_6 = 5;//fdc verin 6 sorti
const byte FDC_Repos_24 = 6;//fdc verin 24 rentré
const byte FDC_Travail_24 = 7;//fdc verin 24 sorti
const byte capteur_ligne_24 = 8;//palpeur flacons devant rateau 24
const byte capteur_zone24_libre = 9;//zone 24 libre
const byte capteur_1 = 10;//capteur en attente
const byte capteur_2 = 11;//capteur en attente
// les actionneurs
const byte EV_6 = 23;//commande electrovanne verin 6
const byte EV_24 = 25;//commande electrovanne verin 24
const byte actionneur_1 = 33;//actionneur en attente
const byte actionneur_2 = 35;//actionneur en attente
const byte alarme = 37;//sirene ou buzzer
//const byte reserve_sdk_LCD = 20;//réservé pour com de l'ecran I2C
//const byte reserve_scl_LCD = 21;//réservé pour com de l'ecran I2C
//les PCINT
const byte capteur_bouchon = A8; //port K bit 0 PCINT 16
const byte capteur_visse = A9; //port K bit 1 PCINT 17
const byte bouchon_3 = A10;//port K bit 2 PCINT 18
const byte bouchon_4 = A11;//port K bit 3 PCINT 19
const byte bouchon_5 = A12;//port K bit 4 PCINT 20
const byte bouchon_6 = A13;//port K bit 5 PCINT 21
const byte bouchon_7 = A14;//port K bit 6 PCINT 22
const byte bouchon_8 = A15;//port K bit 7 PCINT 23
#define Travail HIGH
#define Repos LOW
#define ON HIGH
#define OFF LOW
enum etape_loop {attente = 0, air = 1, verinsix_rentre,verin_vingt_quatre_rentre,place_libre, sortie_verin_vingt_quatre,
boucle_vingt_quatre_flacons, pousse_une_ligne,nouvelle_ligne,comptage_des_quatre_lignes, total_vingt_quatre,
carton_suivant
} etape_loop = air;
boolean air_present = false;
boolean verin6sorti = false;
boolean verin6rentre = false;
boolean verin24sorti = false;
boolean verin24rentre = false;
boolean verin_6_sorti_SR = false;
boolean verin_6_sorti_RS = false;
boolean verin_6_rentre_SR = false;
boolean verin_6_rentre_RS = false;
boolean verin_24_sorti_SR = false;
boolean verin_24_sorti_RS = false;
boolean verin_24_rentre_SR = false;
boolean verin_24_rentre_RS = false;
//boolean presence_flacon = false;
boolean absence_flacon = true;
boolean pause_actif = false;
boolean reset_actif = false;
boolean flag_reset_pause = true;
boolean zone24_libre = false;
byte etape = 1;
//byte compteur_ligne = 1;
//byte compteur_6 = 0;
byte compteur_24 = 0;
unsigned long anti_rebonds = 200;
unsigned long chrono_presence_flacons = micros() + (anti_rebonds*1000);
unsigned long chrono_absence_flacons = micros() + (anti_rebonds*1000);
unsigned long chrono_4 = micros() + (anti_rebonds*1000);
unsigned long chrono_5 = micros() + (anti_rebonds*1000);
unsigned long chrono_Travail_RS6 = millis() + anti_rebonds;
unsigned long chrono_Repos_RS6 = millis() + anti_rebonds;
unsigned long chrono_Travail_SR6 = millis() + anti_rebonds;
unsigned long chrono_Repos_SR6 = millis() + anti_rebonds;
unsigned long chrono_Travail_RS24 = millis() + anti_rebonds;
unsigned long chrono_Repos_RS24 = millis() + anti_rebonds;
unsigned long chrono_Travail_SR24 = millis() + anti_rebonds;
unsigned long chrono_Repos_SR24 = millis() + anti_rebonds;
//BP_reset_pause
unsigned long chronoBP_reset_pause = millis();
unsigned long BP_reset_pause_long = 3000; // milli secondes appui > 1 seconde sur BP c'est un appui long
unsigned long BP_reset_pause_tres_long = 8000; // milli secondes appui > 2 secondes sur BP c'est un appui long
unsigned long chrono_appui_BP_reset_pause = millis(); // chrono pour appui long ou court sur BP_reset_pause
unsigned long chrono_BP_reset_pause_relache = millis(); // chrono pour anti rebonds au relachement
unsigned long chrono_led_appui_BP_reset_pause = millis();
unsigned long tempo_led_appui_BP_reset_pause = 0;
unsigned long duree_alarme = millis();
unsigned long decompte = millis();
unsigned long debut_alarme = millis();
unsigned long fin_alarme = millis();
long minutes = 0;
long memo_minutes = 0;
bool alarme_1 = false;
bool alarme_2 = false;
bool alarme_3 = false;
bool affiche_pause_actif = true;
bool affiche_pause_inactif = true;
bool appui_BP_reset_pause_valide = false; // flag de validation d'un appui sur le BP après tempo anti-rebonds
bool appui_BP_reset_pause = false; // flag d'appui sur BP avant tempo anti-rebonds
bool appui_BP_reset_pause_tres_long = false; // flag de validation d'un appui très long ( < 3 secondes)
bool appui_BP_reset_pause_long = false; // flag de validation d'un appui long ( entre 1 et 3 secondes)
bool appui_BP_reset_pause_court = false; // flag de validation d'un appui court ( < 1 seconde)
byte flip_flop = 0;
Je te montre un exemple concret sur lequel je but ...
Ce bout de code là compile ...
// ***********************************************************************************
// ****************** Définition générale ******************
// ***********************************************************************************
#include <WiFi.h>
#include <WiFiClient.h>
#include <WebServer.h>
#include <PubSubClient.h>
#include <OneWire.h>
#include <DallasTemperature.h>
//Program routines
#include "PageWeb.h"
#define ONE_WIRE_BUS 21
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);
WiFiClient espClient;
PubSubClient client(espClient);
// ***********************************************************************************
// ****************** Configuration de l'interface WIFI & MYQTT ******************
// ***********************************************************************************
const char* ssid = "Unifi-Network";
const char* password = "hphhvh-Zyw1uw-eisde5";
#define mqtt_server "192.168.1.102"
#define mqtt_user "mqtt-user"
#define mqtt_password "ab24xu3D"
#define temperature_topic "sensor/temperature"
Celui ci refuse, j'ai une erreur lors de la compilation. J'ai juste déplacé une ligne comme tu peu le voir.
// ***********************************************************************************
// ****************** Définition générale ******************
// ***********************************************************************************
#include <WiFi.h>
#include <WiFiClient.h>
#include <WebServer.h>
#include <PubSubClient.h>
#include <OneWire.h>
#include <DallasTemperature.h>
//Program routines
#include "PageWeb.h"
//#define ONE_WIRE_BUS 21
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);
WiFiClient espClient;
PubSubClient client(espClient);
// ***********************************************************************************
// ****************** Configuration de l'interface WIFI & MYQTT ******************
// ***********************************************************************************
const char* ssid = "Unifi-Network";
const char* password = "hphhvh-Zyw1uw-eisde5";
#define mqtt_server "192.168.1.102"
#define mqtt_user "mqtt-user"
#define mqtt_password "ab24xu3D"
#define temperature_topic "sensor/temperature"
#define ONE_WIRE_BUS 21
Donc pour quelle raison la compilation n'aboutie pas ??
Voici l'erreur:
L'anglais classique me pose déjà problème alors je parle pas du technique. Y'a pas moyen d'avoir la sortie du compilateur en Français?
/Users/franck/Documents/Arduino/Breiz-Router/breiz-Routeur/breiz-Routeur.ino:16:17: error: 'ONE_WIRE_BUS' was not declared in this scope
OneWire oneWire(ONE_WIRE_BUS);
^~~~~~~~~~~~
/Users/franck/Documents/Arduino/Breiz-Router/breiz-Routeur/breiz-Routeur.ino:16:17: note: the macro 'ONE_WIRE_BUS' had not yet been defined
/Users/franck/Documents/Arduino/Breiz-Router/breiz-Routeur/breiz-Routeur.ino:31: note: it was later defined here
exit status 1
Compilation error: 'ONE_WIRE_BUS' was not declared in this scope
Le message est assez explicite, (même passé à google translate pour traduction)
ONE_WIRE_BUS est utilisé avant d'être déclaré. Le compilateur te dis même où il a trouvé ladite définition pour que tu puisses la placer au bon endroit.
Donc en faite la ligne qui définit le gpio utilisé doit impérativement avant tout le reste, c'est bien cela?
#define ONE_WIRE_BUS 21
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);
WiFiClient espClient;
PubSubClient client(espClient);
Donc sa montre bien que le programme est lu de haut en bas.
Ce n'est pas aussi simple que ça. Déjà il faut distinguer l'exécution et les différentes étapes de la compilation.
On va dire que c'est en tout cas plus logique de définir les choses avant de les utiliser. Pour l'humain en tout cas c'est plus facile que de faire défiler des centaines de lignes de code pour retrouver une définition perdue quelque part dans le code.
Ça semble effectivement logique.
Ce qui suit est bien une "fonction" ?
if (millis() - previousTempsMillis >= 5000) {
previousTempsMillis = millis();
Serial.print("Tension: ");
Serial.println(Uef);
Serial.print("Courant: ");
Serial.println(Ief);
Serial.print("Puissance: ");
Serial.println(PW);
Elle doit tourner dans la boucle Loop, peu-t-on l'écrire de cette façon et ensuite l'appeler depuis le boucle?
void affichage () {
if (millis() - previousTempsMillis >= 5000) {
previousTempsMillis = millis();
Serial.print("Tension: ");
Serial.println(Uef);
Serial.print("Courant: ");
Serial.println(Ief);
Serial.print("Puissance: ");
Serial.println(PW);
}
}
Non, ça, c'est juste un bloc de code.
Une fonction commence par
<type_retourné> nomDeLaFonction(argument, ...){
code de la fonction
}
Oui, tu pourras faire ainsi mais il faudra l'appeler le plus souvent possible si tu veux que le temps soit à peu près respecté. Il faut en particulier qu'il n'y ait pas de code bloquant ni dans loop(), ni dans les fonctions appelées dans loop().
Il serait peut-être plus logique d'avoir cette partie de code dans loop()
if (millis() - previousTempsMillis >= 5000) {
previousTempsMillis = millis();
affichage();
}
Et ne faire que de l'affichage dans affichage(). Ainsi, si tu devais forcer l'affichage pour une raison ou pour une autre à un autre moment tu ne serais pas gêné par la temporisation.
Le code bloquant c'est un delay() par exemple?
La temporisation de 5000 n'est pas critique dans le sens que c'est juste pour que cela s'affiche de manière plus lente pour que sa consultation dans le terminal soit plus lisible, ça ne sert qu'une seul fois pour le parametrage et ensuite on sans sert plus.
J'ai fait la chose suivante juste avant le bloc void setup ()
void affichage_tcp () {
if (millis() - previousTempsMillis >= 900) {
previousTempsMillis = millis();
Serial.print("Tension: ");
Serial.println(Uef);
Serial.print("Courant: ");
Serial.println(Ief);
Serial.print("Puissance: ");
Serial.println(PW);
}
}
et ensuite cela dans la boucle
affichage_tcp();
C'est correct ?
Oui (et vous pouvez vérifier que ça marche)
et non : comme fdufnews vous l'a indiqué, il vaut mieux dédier une fonction à l'affichage (et elle ne fait que ça) et laisser la gestion des temporisations dans loop (par exemple). Avoir des fo,ctions qui ont deux (voire plus) ... fonctions est une source de désordre et de difficultés à mette au point/faire évoluer
Alors, pourquoi ne pas le mettre dans setup? (avec un délai bloquant, par exemple, qu'on consulte 5/10 secondes au demarrage)
Non, je ne suis pas d'accord.
Le sens que tu donne à lire n'est pas correcte.
le programme est lu de haut en bas, uniquement pour les déclarations et initialisation.
ensuite la couche Arduino appel, quelque soit l'ordre dans lequel tu les as mis, une fois la fonction setup, puis indéfiniment la fonction loop.
Enfin un peu de bon sens dans un monde de brutes: Fortran 54 (et jusqu'à 77 malheureusement inclus) ne connaissait que les déclarations après l'appel (dû à une conception préhistorique); C et plein d'autres langages de programmerie modernes déclarent les fonctions avant l'appel, ce qui simplifie l'écriture de compilateurs (dans les années 70, ça avait un sens d'avoir des compilaturs rapides et simples) et surtout la lecture.
Pour éviter de traumatiser (ou pour différer e traumatisme) les débutants, Arduino permet, grâce à un préprocesseur, de mettre les fonctions "n'importe où". Le gain apparent ne compense en aucune façon
This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.