Horloge GPS client-serveur ESP32

Une horloge ESP32 serveur WiFi, pilotée par GPS, + horloge ESP32 client.
Cette réalisation nous permettra donc de nous familiariser avec :
- la programmation des microcontrôleurs ESP32.
- la connexion d'un module récepteur GPS NEO-6M à un ESP32.
- la création d'un réseau local WiFi autonome (ne nécessitant pas de box routeur internet).
- l'échange de données directement entre deux ESP32 par WiFi (requête et retour au format html).
- l'utilisation d'une mini carte ESP32 TTGO T-display (avec affichage intégré OLED couleur).

1 Le serveur de temps GPS

Le serveur dans son boîtier imprimé en 3D sur une Ender3 Pro.

- à droite le cordon d'alim 5V avec son adaptateur USB-C
- en haut le connecteur SMA pour la liaison à l'antenne GPS.

2 Le serveur vu de dos :

La carte ESP32 configurée en serveur WiFi 2.4GHz + le module GPS absorbent (et restituent en chaleur) environ 5V x 50mA = 0.25W, ce qui suffit à élever significativement la température dans cette très petite boite. D'où la grille pour l'aération. Il est extrêmement simple de dessiner une telle structure avec le logiciel libre FreeCad. Vous trouverez les sources au bas de la page.

3 Dans la boite :

Ici on voit surtout le module GPS.

La petite vis près du connecteur SMA sert à le fixer en rotation (avec une petite équerre en laiton, soudée).

4 Le carte ESP32 TTGO t-display

L"écran couleur LCD de 1.14" a une définition de 135 x 240 pixels. Çà peut paraître peu, mais compte tenu de la taille minuscule de l'afficheur, c'est tout à fait suffisant : on ne discerne pas les pixels à l’œil nu, et les images sont parfaitement nettes.

A noter toutefois une particularité étonnante : le connecteur USB est un modèle USB-C (qui se branche donc indifféremment dans les deux sens, mais qui nécessite un adaptateur pour pouvoir être connecté à un câble USB classique).

5 Schéma du serveur

C'est sans doute le schéma le plus simple que j'ai eu à dessiner !

Les pins GPIO37 et GPIO38 choisis pour la liaison série (RX-TX) sont définis dans le logiciel.

static const int RxPin = 38; // UART pin_in relié à GPS_Tx static const int TxPin = 37; // UART pin_out relié à GPS_Rx

On peut choisir autre chose, en fonction de la présence d'éventuels périphériques supplémentaires... Ce qui compte c'est que la sortie de l'un soit relié à l'entrée de l'autre, et vice-versa.

6 Le code source en C++ du serveur :

CODE SOURCE en C++
  1. /***********
  2.   GPS_Time & SERVEUR WiFi local (ip=192.168.4.1/)
  3.   pour ESP32 (TTGO T-Display, avec petit ecran LCD couleur IPS ST7789V 1.14 Inch 135x240 px)
  4.   + module NEO-6M
  5.  
  6. il faut choisir (décommenter) la ligne suivante, dans le fichier /libraries/TFT_eSPI/User_Setup_Select.h :
  7.   #include <User_Setups/Setup25_TTGO_T_Display.h> // Setup file for ESP32 and TTGO T-Display ST7789V SPI bus TFT
  8.  
  9.   voir l'exemple "Colour_Test"
  10.  
  11. ************/
  12.  
  13. #define Version "1.1"
  14.  
  15. #include <SoftwareSerial.h>
  16. #include <TinyGPS.h> // include TinyGPS++ library
  17. #include <TFT_eSPI.h>
  18. #include <TimeLib.h> // include Arduino time library
  19. #include <WiFi.h>
  20.  
  21. // #include <WebServer.h>
  22. #include "ESPAsyncWebServer.h"
  23.  
  24.  
  25. const char* ssid = "TPHGS_26";
  26. const char* password = "hd2y8sd5f";
  27.  
  28.  
  29. // WebServer server(80);
  30. AsyncWebServer server(80); // Create AsyncWebServer object on port 80
  31.  
  32.  
  33. static const int RxPin = 38; // UART pin_in relié à GPS_Tx
  34. static const int TxPin = 37; // UART pin_out relié à GPS_Rx
  35.  
  36. TinyGPS GPS;
  37. TFT_eSPI ECRAN_1 = TFT_eSPI();
  38. SoftwareSerial ss(RxPin, TxPin);
  39.  
  40.  
  41. unsigned long age_GPS;
  42. unsigned long date_GPS;
  43. unsigned long heure_GPS;
  44.  
  45.  
  46. uint16_t annee;
  47. uint8_t mois;
  48. uint8_t jour;
  49. uint8_t heures=0;
  50. uint8_t minutes=0;
  51. uint8_t secondes=0;
  52. uint8_t jour_de_la_semaine;
  53.  
  54. uint16_t compte1=0;
  55.  
  56.  
  57. String annee_txt;
  58. String mois_txt;
  59. String jour_txt;
  60. String date_txt;
  61. String date_txt_compacte;
  62.  
  63. String heures_txt;
  64. String minutes_txt;
  65. String secondes_txt;
  66.  
  67.  
  68. char heure_array[9]; // 23:56:02 + zero terminal
  69. char date_array[17]; // Sam 30 Janv 2021 + zero terminal
  70.  
  71. void setup()
  72. {
  73. Serial.begin(115200);
  74. ss.begin(9600);
  75.  
  76. Serial.println("\n");
  77.  
  78.  
  79. ECRAN_1.init();
  80. ECRAN_1.setRotation(1);
  81. ECRAN_1.fillScreen(TFT_BLACK);
  82. ECRAN_1.setCursor(0, 0, 2); // Set "cursor" at top left corner of display (0,0) and select font 4
  83. ECRAN_1.setTextColor(TFT_WHITE, TFT_BLACK);
  84. ECRAN_1.println("Horloge GPS + serveur WiFi");
  85. delay(500);
  86. ECRAN_1.setCursor(0, 20, 4);
  87. ECRAN_1.setTextColor(TFT_YELLOW, TFT_BLACK);
  88. ECRAN_1.println("Connexion...");
  89.  
  90. WiFi.persistent(false);
  91.  
  92. WiFi.softAP(ssid, password); // ok, ça marche, crée un réseau. mode privé
  93.  
  94. IPAddress IP = WiFi.softAPIP();
  95. Serial.print("AP IP address: "); Serial.println(IP);
  96.  
  97. Serial.println(WiFi.status());
  98. // while (WiFi.status() != WL_CONNECTED) // <------ ne marche pas ! toujours = 255
  99. // while (WiFi.localIP().toString() == "0.0.0.0") // <------ ne marche pas non plus !!
  100. {
  101. Serial.print("...");
  102. delay(200);
  103. }
  104.  
  105.  
  106.  
  107. //= heures_txt +":" + minutes_txt +":" + secondes_txt;
  108. server.on("/heure", HTTP_GET, [](AsyncWebServerRequest *request)
  109. {
  110. request->send_P(200, "text/plain", heure_array);
  111. });
  112.  
  113.  
  114. server.on("/date", HTTP_GET, [](AsyncWebServerRequest *request)
  115. {
  116. request->send_P(200, "text/plain", date_array);
  117. });
  118.  
  119.  
  120.  
  121. server.begin();
  122.  
  123. Serial.println("Serveur web actif!");
  124.  
  125. ECRAN_1.setTextColor(TFT_GREEN, TFT_BLACK);
  126. ECRAN_1.println("Serveur web actif !");
  127.  
  128. smartdelay(2000);
  129. ECRAN_1.fillScreen(TFT_BLACK);
  130.  
  131. ECRAN_1.setCursor(200, 0, 2); // Set "cursor" at top left corner of display (0,0) and select font 4
  132. ECRAN_1.setTextColor(TFT_BLUE, TFT_BLACK);
  133. ECRAN_1.println("GPS");
  134.  
  135. delay(1000);
  136. GPS.get_datetime(&date_GPS, &heure_GPS, &age_GPS);
  137. decode_time(date_GPS, heure_GPS);
  138. affiche_date();
  139. }
  140.  
  141.  
  142.  
  143. static void smartdelay(unsigned long ms)
  144. {
  145. unsigned long start = millis();
  146. do
  147. {
  148. while (ss.available()) { GPS.encode(ss.read()); }
  149. }
  150. while (millis() - start < ms);
  151. }
  152.  
  153.  
  154. void decode_time(int32_t date_GPS, int32_t time_GPS)
  155. {
  156. annee = date_GPS % 100;
  157. mois = (date_GPS / 100) % 100;
  158. jour = date_GPS / 10000;
  159. heures = time_GPS / 1000000;
  160.  
  161. heures +=1; //l'hiver +=1 ; l'été -> += 2
  162.  
  163. minutes = (time_GPS / 10000) % 100;
  164. secondes = (time_GPS / 100) % 100;
  165.  
  166. annee_txt="";
  167. if (annee<10) {annee_txt="0";}
  168. annee_txt += (String) annee;
  169.  
  170. mois_txt="";
  171. if (mois<10) {mois_txt="0";}
  172. mois_txt += (String) mois;
  173.  
  174. jour_txt="";
  175. if (jour<10) {jour_txt="0";}
  176. jour_txt += (String) jour;
  177.  
  178. heures_txt="";
  179. if (heures<10) {heures_txt="0";}
  180. heures_txt += (String) heures;
  181.  
  182. minutes_txt="";
  183. if (minutes<10) {minutes_txt="0";}
  184. minutes_txt += (String) minutes;
  185.  
  186. secondes_txt="";
  187. if (secondes<10) {secondes_txt="0";}
  188. secondes_txt += (String) secondes;
  189. }
  190.  
  191.  
  192. void calcul_jour_de_la_semaine()
  193. {
  194. // d'après l'Algorithme de Mike Keith
  195. uint16_t d, m, y, z, jds;
  196.  
  197. d=jour;
  198. m=mois;
  199. y=annee;
  200.  
  201. if (m>=3)
  202. {
  203. jds = ( ((23*m)/9) + d + 4 + y + (y/4) - (y/100) + (y/400) - 2 ) % 7;
  204. }
  205. else
  206. {
  207. z = y-1;
  208. jds = ( ((23*m)/9) + d + 4 + y + (z/4) - (z/100) + (z/400) ) % 7;
  209. }
  210. jour_de_la_semaine = jds;
  211. }
  212.  
  213.  
  214. String conv_time(uint8_t t)
  215. {
  216. String r;
  217. r=String(t);
  218. if (t<10) {r="0"+r;}
  219. return r;
  220. }
  221.  
  222.  
  223.  
  224. void affiche_date()
  225. {
  226. uint16_t box2_x = 0;
  227. uint16_t box2_y = 121-20;
  228. uint16_t box2_w = 175;
  229. uint16_t box2_h = 20;
  230.  
  231. date_txt="";
  232.  
  233. calcul_jour_de_la_semaine();
  234.  
  235.  
  236. switch (jour_de_la_semaine)
  237. {
  238. case 0: { date_txt+="Dim ";} break;
  239. case 1: { date_txt+="Lun ";} break;
  240. case 2: { date_txt+="Mar ";} break;
  241. case 3: { date_txt+="Mer ";} break;
  242. case 4: { date_txt+="Jeu ";} break;;
  243. case 5: { date_txt+="Ven ";} break;
  244. case 6: { date_txt+="Sam ";} break;
  245. }
  246.  
  247. date_txt += String(conv_time(jour))+" ";
  248.  
  249. switch (mois)
  250. {
  251. case 1: {date_txt+="Janv "; } break;
  252. case 2: {date_txt+="Fev "; } break;
  253. case 3: {date_txt+="Mars "; } break;
  254. case 4: {date_txt+="Avr "; } break;
  255. case 5: {date_txt+="Mai "; } break;
  256. case 6: {date_txt+="Juin "; } break;
  257. case 7: {date_txt+="Juil "; } break;
  258. case 8: {date_txt+="Aout "; } break;
  259. case 9: {date_txt+="Sept "; } break;
  260. case 10: {date_txt+="Oct "; } break;
  261. case 11: {date_txt+="Nov "; } break;
  262. case 12: {date_txt+="Dec "; } break;
  263. }
  264.  
  265. date_txt + "20"; // ce sera le bug de l'an 3000 ;)
  266. date_txt += annee_txt;
  267.  
  268. ECRAN_1.setCursor(0, 100, 4);
  269. ECRAN_1.setTextColor(TFT_CYAN, TFT_BLACK);
  270. ECRAN_1.print(date_txt);
  271.  
  272. }
  273.  
  274.  
  275.  
  276. void affiche_heure()
  277. {
  278. ECRAN_1.setCursor(20, 30, 6);
  279. ECRAN_1.setTextColor(TFT_YELLOW, TFT_BLACK);
  280. ECRAN_1.print(heures);
  281. ECRAN_1.print(":");
  282. if(minutes<10){ECRAN_1.print(0);}
  283. ECRAN_1.print(minutes);
  284.  
  285. ECRAN_1.print(" ");
  286. ECRAN_1.setTextColor(TFT_DARKGREY, TFT_BLACK);
  287. if(secondes<10){ECRAN_1.print(0);}
  288. ECRAN_1.print(secondes);
  289. }
  290.  
  291.  
  292. void loop()
  293. {
  294.  
  295. Serial.println(compte1);
  296. // date as ddmmyy, time as hhmmsscc, and age in milliseconds
  297. // void get_datetime(unsigned long *date, unsigned long *time, unsigned long *age = 0);
  298.  
  299. GPS.get_datetime(&date_GPS, &heure_GPS, &age_GPS);
  300. decode_time(date_GPS, heure_GPS);
  301.  
  302. Serial.print("date_GPS: "); Serial.println(date_GPS);
  303. Serial.print("heure_GPS: "); Serial.println(heure_GPS);
  304.  
  305. Serial.print("annee= "); Serial.println(annee);
  306. Serial.print("mois= "); Serial.println(mois);
  307. Serial.print("jour= "); Serial.println(jour);
  308.  
  309. Serial.print("heures= "); Serial.println(heures);
  310. Serial.print("minutes= "); Serial.println(minutes);
  311. Serial.print("secondes= "); Serial.println(secondes);
  312.  
  313. Serial.print("heures_txt= "); Serial.println(heures_txt);
  314. Serial.print("minutes_txt= "); Serial.println(minutes_txt);
  315. Serial.print("secondes_txt= "); Serial.println(secondes_txt);
  316.  
  317.  
  318. heure_array[0]=heures_txt[0];
  319. heure_array[1]=heures_txt[1];
  320. heure_array[2]=':';
  321. heure_array[3]=minutes_txt[0];
  322. heure_array[4]=minutes_txt[1];
  323. heure_array[5]=':';
  324. heure_array[6]=secondes_txt[0];
  325. heure_array[7]=secondes_txt[1];
  326. heure_array[8]=0; // zéro terminal -> string
  327.  
  328. // 31:01:21 pour "31 Janv 2021"
  329.  
  330. date_array[0]=jour_txt[0];
  331. date_array[1]=jour_txt[1];
  332. date_array[2]=':';
  333. date_array[3]=mois_txt[0];
  334. date_array[4]=mois_txt[1];
  335. date_array[5]=':';
  336. date_array[6]=annee_txt[0];
  337. date_array[7]=annee_txt[1];
  338. date_array[8]=0; // zéro terminal -> string
  339.  
  340.  
  341. Serial.println();
  342.  
  343. Serial.print("GPS.satellites: "); Serial.println(GPS.satellites());
  344. Serial.println(" ");
  345.  
  346. Serial.println();
  347.  
  348. affiche_heure();
  349. affiche_date();
  350.  
  351. smartdelay(1000);
  352. compte1++;
  353.  
  354. }
  355.  


7 La seconde horloge : Client WiFi

Même carte ESP32 TTGO T-display dans un boîtier moins profond puisque cette fois il n'y a pas de module GPS.

8 La carte ESP dans le boitier

Le boîtier mesure 55x30mm pour une profondeur de 16mm. Voir le dessin 3D pour le logiciel FreeCad au bas de l'article.

9 Vue d'ensemble des éléments :

Il faut préciser que le câble USB n'est absolument pas nécessaire, aucune donnée n'est transmise de cette façon, et on peut tout à fait alimenter la carte par un petit connecteur prévu pour cela (au dos de la carte).

10 Le code source en C++ du Client WiFi :

CODE SOURCE en C++
  1. /***********
  2.   GPS_Time & CLIENT WiFi local (ip=192.168.4.1/)
  3.   pour ESP32 (TTGO T-Display, avec petit ecran LCD couleur IPS ST7789V 1.14 Inch 135x240 px)
  4.   + module NEO-6M
  5.  
  6. il faut choisir (décommenter) la ligne suivante, dans le fichier /libraries/TFT_eSPI/User_Setup_Select.h :
  7.   #include <User_Setups/Setup25_TTGO_T_Display.h> // Setup file for ESP32 and TTGO T-Display ST7789V SPI bus TFT
  8.  
  9.   voir l'exemple "Colour_Test"
  10.  
  11. ************/
  12.  
  13.  
  14. #include <SoftwareSerial.h>
  15. #include <TFT_eSPI.h>
  16. #include <TimeLib.h> // include Arduino time library
  17.  
  18. #include <WiFi.h>
  19. #include <HTTPClient.h>
  20.  
  21.  
  22. const char* ssid = "ici_nom_du_serveur";
  23. const char* password = "mot_de passe_12345";
  24.  
  25. //IP address with URL path
  26. const char* srvName_heure = "http://192.168.4.1/heure";
  27. const char* srvName_date = "http://192.168.4.1/date";
  28.  
  29. TFT_eSPI ECRAN_1 = TFT_eSPI();
  30.  
  31. String recp_time = "{}";
  32. String recp_date = "{}";
  33.  
  34.  
  35. uint8_t WiFi_status=0;
  36.  
  37. uint32_t memoMillis = 0;
  38. uint32_t currentMillis;
  39. const uint32_t tempo = 2000;
  40.  
  41.  
  42. uint16_t annee;
  43. uint8_t mois;
  44. uint8_t jour;
  45.  
  46. uint8_t annee_in=0;
  47. uint8_t mois_in=0;
  48. uint8_t jour_in=0;
  49.  
  50. uint8_t heures=0;
  51. uint8_t minutes=0;
  52. uint8_t secondes=0;
  53. uint8_t jour_de_la_semaine;
  54.  
  55. uint8_t heures_in=0;
  56. uint8_t minutes_in=0;
  57. uint8_t secondes_in=0;
  58.  
  59. uint16_t compte1=0;
  60. uint16_t compte2=0;
  61.  
  62. String annee_txt;
  63. String mois_txt;
  64. String jour_txt;
  65. String date_txt;
  66.  
  67. String heures_txt;
  68. String minutes_txt;
  69. String secondes_txt;
  70.  
  71.  
  72.  
  73. void setup()
  74. {
  75. Serial.begin(115200);
  76. delay(2000);
  77. Serial.println("ESP CLIENT WiFi");
  78. Serial.println("Setup");
  79.  
  80. ECRAN_1.init();
  81. ECRAN_1.setRotation(1);
  82. ECRAN_1.fillScreen(TFT_BLACK);
  83. ECRAN_1.setCursor(0, 0, 2); // Set "cursor" at top left corner of display (0,0) and select font 4
  84. ECRAN_1.setTextColor(TFT_WHITE, TFT_BLACK);
  85. ECRAN_1.println("Horloge Client WiFi");
  86.  
  87. delay(500);
  88.  
  89. ECRAN_1.setCursor(0, 20, 4);
  90. ECRAN_1.setTextColor(TFT_YELLOW, TFT_BLACK);
  91. ECRAN_1.print("Connexion :");
  92.  
  93. WiFi.persistent(false);
  94. WiFi.begin(ssid, password);
  95. delay(2000);
  96.  
  97.  
  98.  
  99. Serial.println("Connecting");
  100.  
  101. ECRAN_1.setTextColor(TFT_BLUE, TFT_BLACK);
  102. //ECRAN_1.setTextFont(1);
  103. ECRAN_1.setCursor(0, 40, 1);
  104. while(WiFi.status() != WL_CONNECTED)
  105. {
  106. delay(500);
  107. ECRAN_1.print(".");
  108. Serial.print(".");
  109. }
  110.  
  111. Serial.println("");
  112. Serial.print("Connected to WiFi - IP Address : ");
  113. Serial.println(WiFi.localIP());
  114. Serial.println("\n");
  115.  
  116. ECRAN_1.setTextColor(TFT_GREEN, TFT_BLACK);
  117. ECRAN_1.println(" ");
  118. ECRAN_1.println("OK");
  119. smartdelay(500);
  120. ECRAN_1.fillScreen(TFT_BLACK);
  121.  
  122. ECRAN_1.setCursor(130, 0, 2); // Set "cursor" at top left corner of display (0,0) and select font 4
  123. ECRAN_1.setTextColor(TFT_BLUE, TFT_BLACK);
  124. ECRAN_1.println("Client WiFi");
  125.  
  126. delay(500);
  127.  
  128. affiche_date();
  129. }
  130.  
  131.  
  132. void httpGetTime()
  133. {
  134. Serial.println("envoi req Heure");
  135.  
  136. HTTPClient http1;
  137.  
  138. http1.begin(srvName_heure);
  139.  
  140. int httpResponseCode = http1.GET();
  141.  
  142. if (httpResponseCode>0)
  143. {
  144. recp_time = http1.getString();
  145. }
  146. http1.end();
  147. }
  148.  
  149.  
  150. void httpGetDate()
  151. {
  152. Serial.println("envoi req Date");
  153.  
  154. HTTPClient http2;
  155.  
  156. http2.begin(srvName_date);
  157.  
  158. int httpResponseCode = http2.GET();
  159.  
  160. if (httpResponseCode>0)
  161. {
  162. recp_date = http2.getString();
  163. }
  164. http2.end();
  165. }
  166.  
  167.  
  168. static void smartdelay(unsigned long ms)
  169. {
  170. unsigned long start = millis();
  171. while (millis() - start < ms) {;}
  172. }
  173.  
  174.  
  175.  
  176. void ajuste_time()
  177. {
  178.  
  179. if(recp_time.length() == 8)
  180. {
  181. WiFi_status =1;
  182. Serial.println("ajuste_time");
  183. Serial.println( recp_time);
  184. // String data_in = "11:40:30"
  185.  
  186.  
  187. heures_in =(recp_time.substring(0,2)).toInt();
  188. Serial.println(heures_in);
  189.  
  190. minutes_in =(recp_time.substring(3,5)).toInt();
  191. Serial.println(minutes_in);
  192.  
  193. secondes_in =(recp_time.substring(6,8)).toInt();
  194. Serial.println(secondes_in);
  195. //secondes_in++; // pour compenser le temps de traitement
  196.  
  197. if (heures != heures_in) {heures = heures_in;}
  198. if (minutes != minutes_in) {minutes = minutes_in;}
  199. if (secondes != secondes_in) {secondes = secondes_in;}
  200. }
  201. else {WiFi_status=0;}
  202.  
  203. }
  204.  
  205.  
  206. void ajuste_date()
  207. {
  208. Serial.println("ici7");
  209. if(recp_date.length() == 8)
  210. {
  211. WiFi_status =1;
  212. Serial.println("ajuste_date");
  213. Serial.println( recp_date);
  214. // String data_in = "01:02:21"
  215.  
  216. jour_in =(recp_date.substring(0,2)).toInt();
  217. Serial.println(jour_in);
  218.  
  219. mois_in =(recp_date.substring(3,5)).toInt();
  220. Serial.println(mois_in);
  221.  
  222. annee_in =(recp_date.substring(6,8)).toInt();
  223. Serial.println(annee_in);
  224.  
  225.  
  226. if (jour != jour_in) {jour = jour_in;}
  227. if (mois != mois_in) {mois = mois_in;}
  228. if (annee != annee_in) {annee = annee_in;}
  229. }
  230. else {WiFi_status=0;}
  231.  
  232. }
  233.  
  234.  
  235. void calcul_jour_de_la_semaine()
  236. {
  237. // d'après l'Algorithme de Mike Keith
  238. uint16_t d, m, y, z, jds;
  239.  
  240. d=jour;
  241. m=mois;
  242. y=annee;
  243.  
  244. if (m>=3)
  245. {
  246. jds = ( ((23*m)/9) + d + 4 + y + (y/4) - (y/100) + (y/400) - 2 ) % 7;
  247. }
  248. else
  249. {
  250. z = y-1;
  251. jds = ( ((23*m)/9) + d + 4 + y + (z/4) - (z/100) + (z/400) ) % 7;
  252. }
  253. jour_de_la_semaine = jds;
  254. }
  255.  
  256.  
  257. String conv_time(uint8_t t)
  258. {
  259. String r;
  260. r=String(t);
  261. if (t<10) {r="0"+r;}
  262. return r;
  263. }
  264.  
  265.  
  266.  
  267. void affiche_date()
  268. {
  269. date_txt="";
  270.  
  271. calcul_jour_de_la_semaine();
  272.  
  273. switch (jour_de_la_semaine)
  274. {
  275. case 0: { date_txt+="Dim ";} break;
  276. case 1: { date_txt+="Lun ";} break;
  277. case 2: { date_txt+="Mar ";} break;
  278. case 3: { date_txt+="Mer ";} break;
  279. case 4: { date_txt+="Jeu ";} break;;
  280. case 5: { date_txt+="Ven ";} break;
  281. case 6: { date_txt+="Sam ";} break;
  282. }
  283.  
  284. date_txt += String(conv_time(jour))+" ";
  285.  
  286. switch (mois)
  287. {
  288. case 1: {date_txt+="Janv "; } break;
  289. case 2: {date_txt+="Fev "; } break;
  290. case 3: {date_txt+="Mars "; } break;
  291. case 4: {date_txt+="Avr "; } break;
  292. case 5: {date_txt+="Mai "; } break;
  293. case 6: {date_txt+="Juin "; } break;
  294. case 7: {date_txt+="Juil "; } break;
  295. case 8: {date_txt+="Aout "; } break;
  296. case 9: {date_txt+="Sept "; } break;
  297. case 10: {date_txt+="Oct "; } break;
  298. case 11: {date_txt+="Nov "; } break;
  299. case 12: {date_txt+="Dec "; } break;
  300. }
  301.  
  302. if (annee_in >0) // pour éviter d'afficher une date fantaisiste au départ
  303. {
  304. uint16_t annee_in2 = annee_in + 2000;
  305. annee_txt = (String)annee_in2;
  306. Serial.print("annee_txt="); Serial.println(annee_txt);
  307.  
  308.  
  309. date_txt += annee_txt;
  310.  
  311. ECRAN_1.setCursor(0, 100, 4);
  312. ECRAN_1.setTextColor(TFT_CYAN, TFT_BLACK);
  313. ECRAN_1.print(date_txt);
  314. }
  315.  
  316. }
  317.  
  318.  
  319.  
  320. void affiche_heure()
  321. {
  322. ECRAN_1.setCursor(20, 30, 6);
  323. ECRAN_1.setTextColor(TFT_YELLOW, TFT_BLACK);
  324.  
  325. if(heures<10){ECRAN_1.print(0);}
  326. ECRAN_1.print(heures);
  327. ECRAN_1.print(":");
  328. if(minutes<10){ECRAN_1.print(0);}
  329. ECRAN_1.print(minutes);
  330.  
  331. ECRAN_1.print(" ");
  332. ECRAN_1.setTextColor(TFT_DARKGREY, TFT_BLACK);
  333. if(secondes<10){ECRAN_1.print(0);}
  334. ECRAN_1.print(secondes);
  335.  
  336. if(WiFi_status == 1) {ECRAN_1.fillCircle(233, 5, 5,TFT_GREEN );} else {ECRAN_1.fillCircle(233, 5, 5,TFT_RED );}
  337. }
  338.  
  339.  
  340.  
  341. void incremente_heure(uint8_t nb_s)
  342. {
  343. for (uint8_t n=0; n<nb_s; n++)
  344. {
  345. if (secondes < 59) {secondes+=1;}
  346. else
  347. {
  348. secondes=0;
  349. if (minutes < 59) {minutes+=1;}
  350. else
  351. {
  352. minutes=0;
  353. if (heures < 23) {heures+=1;}
  354. else
  355. heures=0;
  356. }
  357. }
  358. }
  359. }
  360.  
  361.  
  362.  
  363. void loop()
  364. {
  365. compte1++;
  366. Serial.println(compte1);
  367.  
  368. if ((compte1 % 10)==0) // toutes les 10s
  369. {
  370. compte2++;
  371. if (compte2 < 3) // sauf les multiples de 30s (les deux requettes ne doivent pas se collisionner dans le temps)
  372. {
  373. recp_time = "{}";
  374. if(WiFi.status()== WL_CONNECTED )
  375. {
  376. httpGetTime();
  377. ajuste_time();
  378. Serial.println("------");
  379. }
  380. else { Serial.println("WiFi Disconnected"); }
  381. }
  382. if (compte2 >= 3) // toutes les 3x10=30s
  383. {
  384. compte2=0;
  385. recp_date = "{}";
  386. if(WiFi.status()== WL_CONNECTED )
  387. {
  388. httpGetDate();
  389. ajuste_date();
  390. Serial.println("------");
  391. }
  392. else { Serial.println("WiFi Disconnected"); }
  393. }
  394.  
  395. }
  396.  
  397. incremente_heure(1); // 1s
  398. smartdelay(1000);
  399.  
  400. affiche_heure();
  401.  
  402. affiche_date();
  403.  
  404.  
  405. }
  406.  


11 Documents :

Includes : fichiers boitier 3D : :

12 -

Liens...

N'hésitez pas à ajouter un commentaire ici :

Pseudo : Les commentaires font l'objet d'une modération à priori.
Question mathématique :
Click to reload image
=
cliquez sur l'image pour un faire autre calcul.
COMMENTAIRES


892