Discussion :

[SesostrisIII]

Bonjour

j'ai branché sur ma carte arduino Uno un capteur de mouvement HC-SR04, un module UART A6 GSM & GPRS Module SKU: TEL0113 ainsi qu'un buzzer. L'idéea est que lorsque le capteur ultrason détecte quelque chose, un SMS est envoyé à un numéro de téléphone et le buzzer retentit.

Lorsque le capteur ne détecte rien le buzzer est inactif

Je ne parviens pas a envoyer un SMS lorsque le capteur est actif et je ne n'arrive pas faire fonctionner le "else" a la fin du programme lorsqu'il n'y a rien devant le capteur ultrason

voici le code

Merci d'avance
cordialement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
#define trigPin 5      //Trig
#define echoPin 4      //Echo
 
#define buzzer 3 //Buzzer sonore
int mindist = 30; //On indique la distance en dessous de laquelle nous souhaitons voir la led s'allumer
#include <SoftwareSerial.h>
SoftwareSerial mySerial(11, 10);  // TX-Pin11, RX-Pin10
void updateSerial()
{
  delay(2000);
  while (Serial.available()) {
    mySerial.write(Serial.read());//Forward what Serial received to Software Serial Port
  }
  while(mySerial.available()) {
    Serial.write(mySerial.read());//Forward what Software Serial received to Serial Port
  }
 
}
void setup() {
  Serial.begin (9600); 
  pinMode(trigPin, OUTPUT);  //On défini Trig comme une sortie
  pinMode(echoPin, INPUT);   //On défini Echo comme une entrée
  pinMode(LED_BUILTIN, OUTPUT); //On défini la led comme une sortie
  pinMode(buzzer,OUTPUT);//On défini le buzzer comme une sortie
  Serial.begin(9600);
  mySerial.begin(9600);
}
 
void loop() {
  long duree, distance;
  digitalWrite(trigPin, LOW); 
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10); //Trig envois pendant 10ms
  digitalWrite(trigPin, LOW);
 
  // On calcul le temps pour l'aller retour du signal
  duree = pulseIn(echoPin, HIGH);
  distance = duree*340/(2*10000); 
 
  if (distance < mindist) {  // On allume la led si on est moins loin que "mindist", mindist étant défini en début de programme
         digitalWrite(LED_BUILTIN,HIGH);
         digitalWrite(buzzer, LOW);
 
  delay(100);
     mySerial.println("AT");          //Once the handshake test is successful, it will back to OK
  updateSerial();
 
  mySerial.println("AT+CSQ");      //Signal quality test, value range is 0-31, 31 is the best
  updateSerial();
 
  mySerial.println("AT+CCID");    //Read SIM information to confirm whether the SIM is plugged
  updateSerial();
 
  mySerial.println("AT+CREG?");    //Check whether it has registered in the network
  updateSerial();
 
  mySerial.println("AT+SNFS=0");  //Adjust to earphone mode(AT+SNFS=1 is microphone mode)
  updateSerial();
 
  mySerial.println("AT+CRSL=2");  //Adjust volume, volume range is 0-15, maximum:15
  updateSerial();
 
 
  while(1)
  {
    if(mySerial.available())
    {
      Serial.write(mySerial.read());   //Forward what Software Serial received to Serial Port
    if(Serial.available())
    {
      mySerial.write(Serial.read());  //Forward what Serial received to Software Serial Port
    }
  }
}
 mySerial.println("AT");          // Once the handshake test is successful, it will back to OK
 
  updateSerial();
  mySerial.println("AT+CMGF=1");   // Configuring mode is TEST, only English texts are available
  updateSerial();
  mySerial.println("AT+CMGS=\"000000000\"");//xxxxxxxxxxx is the phone number
  updateSerial();
  mySerial.print("HELLO "); //text content
  updateSerial();
  mySerial.write(26);
  while(1)
  {
    if(mySerial.available())
    {
      Serial.write(mySerial.read());//Data received by mySerial will be outputted by Serial
    if(Serial.available())
    {
      mySerial.write(Serial.read());//Data received by Serial will be outputted by mySerial
      }
 
  }
}
}
else {   //sinon on éteind la led
    digitalWrite(buzzer,LOW);
    digitalWrite(LED_BUILTIN,LOW);
 
  }
  delay(100);
  }

[Jay M]

Bonour

Dans ce code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
...
    mySerial.println("AT+CRSL=2");  //Adjust volume, volume range is 0-15, maximum:15
    updateSerial();
    while (1)
    {
      if (mySerial.available())
      {
        Serial.write(mySerial.read());   //Forward what Software Serial received to Serial Port
        if (Serial.available())
        {
          mySerial.write(Serial.read());  //Forward what Serial received to Software Serial Port
        }
      }
    }
...

comment comptez vous sortir du while(1) qui est une boucle infinie...

de plus vous envoyez une commande AT sur le GSM et ensuite appelez updateSerial qui va attendre 2 seconde puis vider les buffers d'entrée série, il y a donc peu de chances que quelques microsecondes plus tard quelque chose traine encore sur mySerial().

En pratique, Serial est un protocole asynchrone, et vous avez un buffer de taille limitée (64 caractères). Quand on travaille avec le port série il ne faut pas essayer de bloquer le flot de donnée en croyant qu'on va tout recevoir... un delay() dans le code est un risque et donc faire cela n'est pas bon

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
void updateSerial()
{
  delay(2000);
  while (Serial.available()) {
    mySerial.write(Serial.read());//Forward what Serial received to Software Serial Port
  }
  while (mySerial.available()) {
    Serial.write(mySerial.read());//Forward what Software Serial received to Serial Port
  }
}

virez les 2 secondes d'attente. s'il y a quelque chose à lire, lisez le, sinon vous ne faites rien et revenez plus tard.

Comme vous balancez des commandes AT, l'idéal serait d'avoir une fonction qui attend la réponse de cette commande. elles se terminent généralement par un "\r\n" (ou l'un des deux), ou un "OK\r\n" --> votre fonction de lecture du port série devrait attendre la fin de la réponse et pas de manière arbitraire deux secondes.

Sinon:

•*pulseIn() retourne un unsigned long, pas un long donc autant déclarer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  unsigned long duree, distance;

•*pour éviter les erreurs d'arrondi dans les calculs entiers au lieu de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  distance = duree * 340 / (2 * 10000);

préférez l'écriture

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  distance = duree / 58;

ou encore

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  distance = duree * 340.0 / (2.0 * 10000);

•*Vous avez deux fois

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  Serial.begin(9600);

dans le setup()


-----------------------------

étudiez l'exemple suivant, qui fonctionne dans la console série réglé à 115200 bauds et envoyant NL et CR lorsque vous validez

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// #include <SoftwareSerial.h>
// SoftwareSerial GSMSerial(11, 10);  // TX-Pin11, RX-Pin10
#define GSMSerial Serial  // juste pour notre exemple

void envoyerCommande(const char* command)
{
  GSMSerial.println(command);
}

bool attendreReponse(const char* marqueurDeFin, unsigned long delaiMax = 2000)
{
  bool marqueurRecu = false;
  const size_t nbCharMarqueurFin =  strlen(marqueurDeFin);
  char buffer[nbCharMarqueurFin + 1]; // +1 pour le \0 de fin
  uint16_t index = 0;
  unsigned long chrono = millis();

  memset(buffer, '\0', nbCharMarqueurFin + 1); // on vide le buffer (cString)

  while (millis() - chrono < delaiMax) {
    char c = GSMSerial.read();
    if (c != -1) {  // -1 veut dire qu'il n'y a pas de caractère à lire
      if (index >= nbCharMarqueurFin) {
        for (size_t i = 0; i < nbCharMarqueurFin - 1; i++) buffer[i] = buffer[i + 1]; // on décale
        buffer[nbCharMarqueurFin - 1] = c;
      } else {
        buffer[index++] = c;
      }
      if (!strcmp(buffer, marqueurDeFin)) { // on a eu un nouveau caractère,  on regarde si le buffer correspond au message de réponse attendu
        marqueurRecu = true;
        break; // on n'attend pas le delaiMax et on note qu'on a bien reçu le marqueur de fin
      }
    }
  }
  return marqueurRecu;
}

void setup()
{
  Serial.begin(115200);
  if (GSMSerial != Serial) GSMSerial.begin(9600); // juste pour notre exemple
}

void loop()
{
  envoyerCommande("COUCOU");
  
  if (attendreReponse("OK\r\n")) {
    Serial.println(F("Reponse correcte"));
  } else {
    Serial.println(F("timeout, Reponse incorrecte"));
  }
}

le code va vous dire "COUCOU" et vous avez deux secondes (la valeur du paramètre delaiMax) pour répondre quelque chose qui finit par OK (avec le \r\n rajouté par la console). Vous pouvez taper juste "OK" dans la console et valider et le code vous dira "Reponse correcte", mais si vous tapez 123456789OK ça fonctione aussi, il suffit juste que la réponse se termine par le "OK\r\n"
Si vous tapez autre chose ou rien du tout, le code vous dira "timeout, Reponse incorrecte".

--> comme cela vous lisez bien la réponse et ne restez pas bloqué car la fonction gère un timeout