Montre T-Watch 2020 v1 (2024) 

  1. /*
  2. pour montre TTGO T-Watch v1
  4. par Silicium628
  6. à voir aussi -> https://projetsdiy.fr/ttgo-t-watch-debuter-librairie-esp32-tft_espi/
  7. */
  9. #define version1 "2.0"
  12. #include "config.h"
  13. #include "Free_Fonts.h" 
  14. #include <EEPROM.h>
  15. #define EEPROM_SIZE 100
  17. #include "data_perso2.c"
  18. #include "Listeuse.h"
  20. bool irq = false;
  22. char buf[128];
  23. bool rtcIrq = false;
  25. TTGOClass *ttgo;
  27. TFT_eSPI * tft;
  29. AXP20X_Class *power;
  31. BOUTON bouton1;
  32. BOUTON bouton2;
  33. BOUTON bouton3;
  34. BOUTON bouton4;
  35. BOUTON bouton5;
  36. BOUTON bouton6;
  37. BOUTON bouton7;
  38. BOUTON bouton8;
  39. BOUTON bouton9;
  40. BOUTON bouton10;
  41. BOUTON bouton11;
  42. BOUTON bouton12;
  43. BOUTON bouton13;
  44. BOUTON bouton14;
  45. BOUTON bouton15;
  48. /***************************************************************************************
  49. ** Section 6: Colour enumeration
  50. ***************************************************************************************/
  51. // Default color definitions
  52. /**
  53. #define TFT_BLACK 0x0000 // 0, 0, 0 
  54. #define TFT_NAVY 0x000F // 0, 0, 128 
  55. #define TFT_DARKGREEN 0x03E0 // 0, 128, 0 
  56. #define TFT_DARKCYAN 0x03EF // 0, 128, 128 
  57. #define TFT_MAROON 0x7800 // 128, 0, 0 
  58. #define TFT_PURPLE 0x780F // 128, 0, 128 
  59. #define TFT_OLIVE 0x7BE0 // 128, 128, 0 
  60. #define TFT_LIGHTGREY 0xD69A // 211, 211, 211 
  61. #define TFT_DARKGREY 0x7BEF // 128, 128, 128 
  62. #define TFT_BLUE 0x001F // 0, 0, 255 
  63. #define TFT_GREEN 0x07E0 // 0, 255, 0
  64. #define TFT_CYAN 0x07FF // 0, 255, 255 
  65. #define TFT_RED 0xF800 // 255, 0, 0 
  66. #define TFT_MAGENTA 0xF81F // 255, 0, 255 
  67. #define TFT_YELLOW 0xFFE0 // 255, 255, 0 
  68. #define TFT_WHITE 0xFFFF // 255, 255, 255 
  69. #define TFT_ORANGE 0xFDA0 // 255, 180, 0 
  70. #define TFT_GREENYELLOW 0xB7E0 // 180, 255, 0 
  71. #define TFT_PINK 0xFE19 // 255, 192, 203 //Lighter pink, was 0xFC9F 
  72. #define TFT_BROWN 0x9A60 // 150, 75, 0 
  73. #define TFT_GOLD 0xFEA0 // 255, 215, 0 
  74. #define TFT_SILVER 0xC618 // 192, 192, 192 
  75. #define TFT_SKYBLUE 0x867D // 135, 206, 235 
  76. #define TFT_VIOLET 0x915C // 180, 46, 226 
  77. **/
  79. bool KeyPressed = false;
  80. bool lenergy = false;
  81. static bool irq_axp202 = false;
  82. static bool return_to_deepsleep = true;
  83. #define TIME_TO_SLEEP 30
  86. uint8_t secondes;
  87. uint8_t heures;
  88. uint8_t minutes;
  90. uint8_t etats[nb_elements]; // nb_elements est défini dans le fichier data_perso2.c
  92. uint8_t lst_num_affi[11]; // liste des numéros des strings actuellement affichés
  93. uint16_t num_ligne_pointee;
  94. uint8_t top_lst=0;
  95. uint8_t lst_a_afficher=1; // =0 ou 1 (2 listes)
  96. uint8_t choix_ok =0;
  97. uint8_t mode=0;
  98. uint8_t reg_heure=0;
  100. int16_t x_1, y_1;
  101. int16_t x_2, y_2;
  102. uint16_t memo_y_2=0;
  105. void init_boutons()
  106. {
  108. // sur la partie listeuse
  110. if(lst_a_afficher == 0)
  111. {
  112. bouton1.init(199,0, 40,40, "fleche_droite", TFT_BROWN);
  113. }
  114. else
  115. {
  116. bouton1.init(199,0, 40,40, "fleche_gauche", TFT_CYAN);
  117. }
  120. bouton1.dessine(0);
  122. String s2; 
  123. if(lst_a_afficher == 0) {s2="x";} else {s2="!";}
  124. bouton2.init(199,65, 40,40, s2, TFT_GREEN);
  125. bouton2.dessine(0);
  127. bouton3.init(199,140, 40,20, "fleche_haut", TFT_WHITE);
  128. bouton3.dessine(0);
  130. bouton4.init(199,200, 40,20, "fleche_bas", TFT_WHITE);
  131. bouton4.dessine(0);
  133. // sur la page de choix
  135. bouton5.init(120,0, 40,40, "W", TFT_RED);
  137. bouton6.init(180,0, 40,40, "R", TFT_GREEN);
  139. bouton7.init(5,80, 100,40, "Montre", TFT_WHITE);
  141. bouton8.init(5,130, 100,40, "Liste", TFT_WHITE);
  143. bouton9.init(150,190, 40,40, "+", TFT_WHITE); // bouton "inc minutes"
  144. bouton10.init(80,190, 40,40, "-", TFT_WHITE); // bouton "dec minutes"
  146. bouton11.init(120,80, 110,40, "Reg h,m", TFT_WHITE); // bouton accès règlage minutes
  148. bouton12.init(120,130, 110,40, "Batt", TFT_WHITE);
  150. bouton13.init(130,200, 100,40, "retour", TFT_WHITE);
  152. bouton14.init(150,40, 40,40, "+", TFT_WHITE); // bouton "inc heures"
  153. bouton15.init(80,40, 40,40, "-", TFT_WHITE); // bouton "dec heures"
  154. }
  157. uint16_t nb_elmt_liste_en_cours()
  158. {
  159. uint16_t nb1=0;
  160. for(int n=0; n<nb_elements; n++)
  161. {
  162. if (etats[n] == lst_a_afficher) {nb1++;}
  163. }
  164. return(nb1);
  165. }
  169. void affiche_data()
  170. {
  171. if (mode==0)
  172. {
  173. String s1;
  174. tft->setFreeFont(FF18);
  175. tft->fillScreen(TFT_BLACK);
  177. if(lst_a_afficher==0) {tft->setTextColor(TFT_CYAN, TFT_BLACK);} else {tft->setTextColor(TFT_BROWN, TFT_BLACK);}
  179. for(uint16_t i=0; i<11; i++) {lst_num_affi[i]=255;} // RAZ liste
  182. int16_t dy=22;
  184. // n'affiche que les lignes de la liste choisie (parmi 2 listes)
  185. uint16_t y=0;
  187. uint8_t i=top_lst;
  188. uint8_t n=0;
  189. while((i<nb_elements) && (n<11))
  190. {
  191. if (etats[i] == lst_a_afficher)
  192. { 
  193. uint16_t num1;
  194. num1 =top_lst + n;
  195. //num1 ++; // pour afficher à partir de 1 au lieu de 0...
  196. s1 =(String)num1;
  197. tft->setFreeFont(FF1);
  198. tft->setTextColor(TFT_SILVER, TFT_BLACK);
  199. tft->drawString(s1, 0, y+2, GFXFF); // affiche les numéros à gauche du texte
  202. String el1 = elements[i];
  203. tft->setFreeFont(FF18);
  204. if(lst_a_afficher==0) {tft->setTextColor(TFT_CYAN, TFT_BLACK);} else {tft->setTextColor(TFT_BROWN, TFT_BLACK);}
  205. tft->drawString(el1, 34, y, GFXFF);
  206. y+=dy;
  207. lst_num_affi[n]=i;
  208. n++;
  209. }
  210. i++;
  211. }
  213. tft->setFreeFont(FF1);
  214. init_boutons();
  216. uint16_t nb_el1;
  218. nb_el1= nb_elmt_liste_en_cours();
  219. s1 =(String)nb_el1;
  220. tft->setTextColor(TFT_WHITE, TFT_BLUE);
  221. tft->setTextFont(2); // très petits caractères
  222. tft->drawString(s1, 220, 225, GFXFF); // affiche le nombre en bas à droite
  223. }
  224. }
  228. void affiche_batterie()
  229. {
  232. tft->fillScreen(TFT_BLACK);
  233. uint8_t fin_bcl=0;
  234. while (fin_bcl == 0)
  235. {
  236. //tft->fillScreen(TFT_BLACK);
  237. tft->fillRect(0, 0, 230, 150, TFT_BLACK);
  238. tft->setTextColor(TFT_CYAN, TFT_BLACK);
  239. tft->setFreeFont(FF1);
  241. bouton13.dessine(0);
  243. tft->setTextColor(TFT_CYAN, TFT_BLACK);
  244. tft->setFreeFont(FF1);
  247. tft->setCursor(0, 10);
  249. tft->print("VBUS ETAT: ");
  251. if (power->isVBUSPlug())
  252. {
  253. tft->setTextColor(TFT_GREEN, TFT_BLACK);
  254. tft->println("CONNECT");
  256. tft->setTextColor(TFT_YELLOW, TFT_BLACK);
  257. tft->print("VBUS V : ");
  258. tft->print(power->getVbusVoltage());
  259. tft->println(" mV");
  261. tft->setTextColor(TFT_BLUE, TFT_BLACK);
  262. tft->print("VBUS I: ");
  263. tft->print(power->getVbusCurrent());
  264. tft->println(" mA");
  265. }
  266. else
  267. {
  268. tft->setTextColor(TFT_RED, TFT_BLACK);
  269. tft->println("DISCONNECT");
  270. tft->setTextColor(TFT_GREEN, TFT_BLACK);
  271. }
  273. tft->println();
  274. tft->setTextColor(TFT_CYAN, TFT_BLACK);
  275. tft->print("BATT Li-Ion : ");
  276. // You can use isBatteryConnect() to check whether the battery is connected properly
  277. if (power->isBatteryConnect())
  278. {
  279. tft->setTextColor(TFT_GREEN, TFT_BLACK);
  280. tft->println("CONNECT");
  282. tft->setTextColor(TFT_YELLOW, TFT_BLACK);
  283. float V=power->getBattVoltage();
  284. V /=1000;
  285. tft->print(V);
  287. tft->println(" V");
  289. // To display the charging status, you must first discharge the battery,
  290. // and it is impossible to read the full charge when it is fully charged
  291. if (power->isChargeing())
  292. {
  293. tft->setTextColor(TFT_BLUE, TFT_BLACK);
  294. tft->print("Charge : ");
  295. tft->print(power->getBattChargeCurrent());
  296. tft->println(" mA");
  297. }
  298. else
  299. {
  300. // Show current consumption
  301. tft->setTextColor(TFT_WHITE, TFT_BLACK);
  302. tft->print("Decharge : ");
  303. tft->print(power->getBattDischargeCurrent());
  304. tft->println(" mA");
  306. tft->print(power->getBattPercentage());
  307. tft->println(" %");
  309. }
  310. }
  311. else
  312. {
  313. tft->setTextColor(TFT_RED, TFT_BLACK);
  314. tft->println("DISCONNECT");
  315. tft->setTextColor(TFT_GREEN, TFT_BLACK);
  316. }
  318. for(int n=0; n<10; n++) // pour obtenir un temps de réaction très bref en gardant une tempo de 1s
  319. {
  321. if (ttgo->getTouch(x_1, y_1))
  322. {
  323. fin_bcl=1;
  324. affi_choix();
  325. mode=1;
  326. }
  327. delay(100);
  328. }
  331. }
  333. }
  337. void affi_choix()
  338. {
  340. tft->fillScreen(TFT_BLACK);
  342. tft->setTextColor(TFT_CYAN, TFT_BLACK);
  343. tft->setFreeFont(FF18);
  345. tft->drawString("Eeprom :", 10, 5, GFXFF);
  347. tft->drawLine(0, 45, 239, 45, TFT_WHITE);
  349. //tft->drawString("Fonction :", 10, 55, GFXFF);
  351. bouton5.dessine(0);
  352. bouton6.dessine(0);
  353. bouton7.dessine(0);
  354. bouton8.dessine(0);
  355. bouton11.dessine(0);
  356. bouton12.dessine(0);
  357. }
  362. void setup()
  363. {
  364. //Serial.begin(115200);
  365. //Serial.println("setup()");
  367.  EEPROM.begin(EEPROM_SIZE); // en mémoire flash
  369.  ttgo = TTGOClass::getWatch();
  370.  ttgo->begin();
  372. power = ttgo->power;
  374.  ttgo->openBL(); // allume le rétroéclairage
  375.  ttgo->bl->adjust(150); //Lower the brightness
  377. tft = ttgo->tft;
  379. tft->fillScreen(TFT_BLACK);
  381. ttgo->rtc->disableAlarm();
  382. // ttgo->rtc->setDateTime(2021, 03, 12, 17, 21, 30); // commenter cette ligne sauf pour remettre à l'heure
  384. for(int n =0; n<nb_elements; n++)
  385. {
  386. etats[n]= 1;
  387. }
  389. uint16_t dy=22;
  390. uint16_t decal=0;
  392. //for(int decal =0; decal<nb_elements; decal++)
  393. {
  394. uint16_t y=0;
  395. tft->fillScreen(TFT_BLACK);
  397. affiche_data();
  399. delay(100);
  400. }
  402. init_boutons();
  404. uint8_t v1 = EEPROM.read(0);
  405. String s1;
  406. s1 =(String)v1;
  407. tft->setFreeFont(FF1);
  408. tft->setTextColor(TFT_SILVER, TFT_BLACK);
  409. tft->drawString(s1, 150, 70, GFXFF);
  411. pinMode(AXP202_INT, INPUT_PULLUP);
  412.  attachInterrupt(AXP202_INT, []
  413. {
  414.  irq = true;
  415. }, FALLING);
  417. //!Clear IRQ unprocessed first
  419.  power->enableIRQ(AXP202_PEK_SHORTPRESS_IRQ | AXP202_VBUS_REMOVED_IRQ | AXP202_VBUS_CONNECT_IRQ | AXP202_CHARGING_IRQ, true);
  420. // ADC monitoring must be enabled to use the AXP202 monitoring function
  421.  power->adc1Enable(AXP202_VBUS_VOL_ADC1 | AXP202_VBUS_CUR_ADC1 | AXP202_BATT_CUR_ADC1 | AXP202_BATT_VOL_ADC1, true);
  423.  power->clearIRQ();
  425.  read_eeprom();
  426. mode=0;
  427. lst_a_afficher=0;
  429. //affi_choix();
  430. //affiche_data();
  432. affiche_heure();
  434. }
  438. void trace_curseur_triangulaire(uint16_t x, uint16_t y, uint32_t couleur)
  439. {
  440. tft->fillTriangle (x, y-12, x, y+6, x+10, y-2, couleur);
  441. }
  445. void affi_string(String s, uint16_t x, uint16_t y)
  446. {
  447. tft->setFreeFont(FF1);
  448. tft->setTextColor(TFT_WHITE, TFT_BLACK);
  449. tft->drawString(" ", x, y, GFXFF);
  450. tft->drawString(s, x, y, GFXFF);
  451. }
  455. void affi_int(uint16_t k, uint16_t x, uint16_t y)
  456. {
  457. String s1 =(String)k;
  458. tft->setFreeFont(FF1);
  459. tft->setTextColor(TFT_WHITE, TFT_BLACK);
  460. tft->drawString(" ", x, y, GFXFF);
  461. tft->drawString(s1, x, y, GFXFF);
  462. }
  466. void affi_message(String m1)
  467. {
  468. tft->setTextColor(TFT_WHITE, TFT_BLUE);
  469. tft->setFreeFont(FF18); 
  470. ttgo->tft->drawString(m1, 25, 100);
  471. delay(1000);
  472. affiche_data();
  473. }
  476. void record_etat()
  477. {
  478. if (nb_elements > 100) {return;}
  479. int adresse =0;
  480. uint8_t nbe = nb_elements;
  481. for(int n=0; n<nb_elements; n++)
  482. {
  483. EEPROM.write(adresse, etats[n]);
  484. EEPROM.commit();
  485. delay(5);
  486. adresse ++;
  487. }
  488. }
  491. void read_eeprom()
  492. {
  493. int adresse =0;
  494. for(int n=0; n<nb_elements; n++)
  495. {
  496. uint8_t v;
  497. v = EEPROM.read(adresse);
  498. //Serial.print(n); Serial.print(": "); Serial.println(v);
  499. etats[n]=v;
  500. adresse ++;
  501. }
  502. }
  506. void inc_heures()
  507. {
  508. RTC_Date dt1 = ttgo->rtc->getDateTime();
  510. if (dt1.hour<23) {dt1.hour++;}
  511. ttgo->rtc->setDateTime(dt1);
  512. }
  515. void dec_heures()
  516. {
  517. RTC_Date dt1 = ttgo->rtc->getDateTime();
  519. if (dt1.hour>0) {dt1.hour--;}
  520. ttgo->rtc->setDateTime(dt1);
  521. }
  525. void inc_minutes()
  526. {
  527. RTC_Date dt1 = ttgo->rtc->getDateTime();
  529. if (dt1.minute<59) {dt1.minute++;}
  530. else
  531. {
  532. dt1.hour++;
  533. dt1.minute=0;
  534. }
  536. ttgo->rtc->setDateTime(dt1);
  537. }
  540. void dec_minutes()
  541. {
  542. RTC_Date dt1 = ttgo->rtc->getDateTime();
  544. if (dt1.minute>0) {dt1.minute--;}
  545. else
  546. {
  547. dt1.hour--;
  548. dt1.minute=59;
  549. }
  551. ttgo->rtc->setDateTime(dt1);
  552. }
  558. void affiche_heure()
  559. {
  560. uint32_t d2;
  561. String s1, s2;
  563. tft->fillScreen(TFT_BLACK);
  565. if (reg_heure==1)
  566. {
  567. tft->fillScreen(TFT_BLACK);
  569. tft->setTextColor(TFT_CYAN, TFT_BLACK);
  570. tft->setFreeFont(FF18);
  571. tft->drawString("h:", 10, 50, GFXFF);
  573. bouton14.dessine(0);
  574. bouton15.dessine(0);
  576. tft->setTextColor(TFT_CYAN, TFT_BLACK);
  577. tft->setFreeFont(FF18);
  578. tft->drawString("mn :", 10, 200, GFXFF);
  580. bouton9.dessine(0);
  581. bouton10.dessine(0);
  583. bouton14.dessine(0);
  584. bouton15.dessine(0);
  585. }
  587. //ttgo->tft->setTextColor(TFT_YELLOW, TFT_BLACK);
  589. uint8_t stop=0;
  590. while(stop==0)
  591. {
  593. ttgo->tft->setTextColor(TFT_YELLOW, TFT_BLACK);
  594. RTC_Date dt1 = ttgo->rtc->getDateTime();
  595. heures = dt1.hour;
  596. s1="";
  597. if (heures<10) {s1 +="0";}
  598. s1+= String(heures);
  599. s1+=":";
  601. minutes = dt1.minute;
  602. if (minutes<10) {s1 +="0";}
  603. s1 += String (minutes);
  604. s1+=" ";
  606. tft->setFreeFont(FM24);
  607. ttgo->tft->drawString(s1, 40, 100);
  610. secondes = dt1.second;
  611. s2 = String (secondes);
  612. s2+=" ";
  614. tft->setFreeFont(FM12);
  615. ttgo->tft->setTextColor(TFT_BLUE, TFT_BLACK);
  616. ttgo->tft->drawString(s2, 40, 150);
  618. if (irq)
  619. {
  620. ttgo->power->readIRQ();
  621. if (ttgo->power->isPEKShortPressIRQ())
  622. {
  623. ttgo->power->clearIRQ();
  624. stop=1;
  625. }
  626. //irq = false;
  627. }
  629. if (reg_heure==1)
  630. {
  631. if (ttgo->getTouch(x_1, y_1))
  632. {
  633. if (detect_btn(&bouton9)) { inc_minutes(); }
  634. if (detect_btn(&bouton10)) { dec_minutes(); }
  635. if (detect_btn(&bouton14)) { inc_heures(); }
  636. if (detect_btn(&bouton15)) { dec_heures(); }
  638. }
  639. }
  640. if (stop ==0) {delay(500);}
  641. }
  643. reg_heure=0;
  644. mode=1;
  645. affi_choix();
  647. }
  650. int detect_btn(BOUTON *bouton_i)
  651. {
  652. // calcul de la distance^2 du point cliqué / centre du bouton; rappel : sq = fonction "carré de"
  653. // d²=dx²+dy²
  654. // inutile d'en prendre la racine carrée, on peut utiliser la valeur d² directement
  655. uint32_t d2;
  657. uint16_t milieu_x = bouton_i->x0 + bouton_i->dx/2;
  658. d2= sq(x_1 - milieu_x) + sq(y_1 - bouton_i->y0);
  660. if (d2 < 2000)
  661. {
  662. bouton_i->dessine(1);
  663. delay (200);
  664. bouton_i->dessine(0);
  665. return(1);
  666. }
  667. else
  668. {
  669. return(0);
  670. }
  672. }
  675. void loop()
  676. {
  677. uint32_t d2;
  680. if (irq)
  681. {
  682. irq = false;
  683. power->readIRQ();
  685. //if (power->isVbusPlugInIRQ()) {affi_message("Power Plug In"); }
  686. //if (power->isVbusRemoveIRQ()) {affi_message("Power Remove"); }
  688. if (power->isPEKShortPressIRQ())
  689. {
  690. affi_choix();
  691. mode=1;
  692. }
  693. power->clearIRQ();
  694. }
  697. if (ttgo->getTouch(x_1, y_1))
  698. {
  699. if(mode==0) // mode "normal"
  700. {
  701. if (x_1<160) // gestion du curseur à gauche
  702. {
  703. num_ligne_pointee = y_1/22;
  705. /** affi_int(num_ligne_pointee, 120, 0); // pour test -> [0..10] **/
  707. x_2=20;
  708. y_2=22*(y_1/22)+12;
  710. uint8_t num_el = lst_num_affi[num_ligne_pointee];
  712. if(((y_2 != memo_y_2) && (num_el != 255))|| (num_ligne_pointee==0) ) // la valeur 255 est inscrite au delà de la fin des éléments présents . cf: affiche_data()
  713. {
  714. /**
  715. affi_int(num_el, 120, 20); // pour test
  716. String s1 = elements[num_el];
  717. affi_string(s1 ,120,40); // pour test
  718. **/
  719. trace_curseur_triangulaire(x_2, memo_y_2, TFT_BLACK); //efface le précédent
  720. trace_curseur_triangulaire(x_2, y_2, TFT_YELLOW); //trace le curseur triangulaire jaune
  721. memo_y_2 = y_2;
  722. bouton2.couleur=TFT_GREEN;
  723. bouton2.dessine(0);
  724. choix_ok=1;
  725. }
  726. }
  727. else // gestion des boutons à droite
  728. {
  729. if (detect_btn(&bouton1))
  730. {
  731. lst_a_afficher=1-lst_a_afficher;
  732. top_lst=0;
  733. affiche_data();
  734. }
  735. if (detect_btn(&bouton2))
  736. {
  737. if (choix_ok==1)
  738. {
  739. uint8_t n_el = lst_num_affi[num_ligne_pointee];
  740. etats[n_el]=1-etats[n_el];
  741. affiche_data();
  742. bouton2.couleur=TFT_DARKGREY;
  743. bouton2.dessine(0);
  744. choix_ok=0;
  745. }
  746. }
  747. if (detect_btn(&bouton3))
  748. {
  749. top_lst=0;
  750. affiche_data();
  751. }
  752. if (detect_btn(&bouton4))
  753. {
  754. uint16_t nb_max = nb_elmt_liste_en_cours();
  755. //if (top_lst < (nb_max-11))
  757. top_lst=lst_num_affi[10]; // on part du dernier élément de l'affichage en cours
  758. //{top_lst+=11;} //attention à cette valeur : elle doit correspondre au nb de lignes affichées
  759. affiche_data();
  760. }
  762. }
  763. }
  764. else if(mode==1) // ecran de choix avec 5 boutons
  765. {
  766. if (detect_btn(&bouton5))
  767. {
  768. record_etat();
  769. }
  771. if (detect_btn(&bouton6))
  772. {
  773. read_eeprom();
  774. mode=0;
  775. lst_a_afficher=0;
  776. affiche_data();
  777. }
  779. if (detect_btn(&bouton7))
  780. {
  781. affiche_heure();
  782. x_1=0;
  783. y_1=0;
  784. }
  786. if (detect_btn(&bouton8))
  787. {
  788. x_1=0;
  789. y_1=0;
  790. mode=0;
  791. affiche_data();
  792. }
  794. if (detect_btn(&bouton11))
  795. {
  796. reg_heure=1;
  797. affiche_heure();
  798. }
  800. if (detect_btn(&bouton12))
  801. {
  802. affiche_batterie();
  803. }
  804. }
  805. }
  807. delay(5);
  808. }
  810. /** ***********************************************************************************
  811. CLASS BOUTON // affiche un bouton cliquable
  812. ***************************************************************************************/
  816. // Constructeur
  817. BOUTON::BOUTON()
  818. {
  820. }
  823. void BOUTON::init(uint16_t x_i, uint16_t y_i, uint16_t dx_i, uint16_t dy_i, String s_i, uint32_t couleur_i)
  824. {
  825.  x0 = x_i;
  826. y0 = y_i;
  827. dx = dx_i;
  828. dy = dy_i;
  829. s = s_i;
  830. couleur =couleur_i;
  831. }
  836. void BOUTON::dessine(uint8_t fill_i)
  837. {
  838. if(fill_i==1)
  839. {
  840. tft->fillRoundRect(x0, y0, dx, dy, 5, couleur);
  842. }
  843. else
  844. {
  845. tft->fillRoundRect(x0, y0, dx, dy, 5, TFT_BLACK); // "éteint" le bouton
  846. tft->drawRoundRect(x0, y0, dx, dy, 5, couleur); // retrace le pourtour
  847. //
  849. if (s=="fleche_haut") {tft->fillTriangle (x0+12, y0+15, x0+30, y0+15, x0+20, y0+5, couleur);}
  850. else if (s=="fleche_bas") {tft->fillTriangle (x0+12, y0+5, x0+30, y0+5, x0+20, y0+15, couleur);}
  851. else if (s=="fleche_droite") {tft->fillTriangle (x0+15, y0+8, x0+15, y0+26, x0+25, y0+18, couleur);}
  852. else if (s=="fleche_gauche") {tft->fillTriangle (x0+25, y0+8, x0+25, y0+26, x0+15, y0+18, couleur);}
  854. else
  855. {
  856. tft->setFreeFont(FF18);
  857. tft->setTextColor(TFT_WHITE, TFT_BLACK);
  858. tft->drawString(s, x0+11, y0+10);
  859. }
  861. }
  863. }
Montre T-Watch 2020 v1 (2024)
Top Articles
USB Rechargeable Flashlight Original Green Box Aluminum Body 3 Stages with LEDs
Troubleshooting Tips for When Your Litter Robot 4 Gets Stuck On Red
Litter-Robot 4 Solid Red Cat or Motion Detection
Latest Posts
Destiny (MHA Next Generations) - One_Lost_Child - 僕のヒーローアカデミア | Boku no Hero Academia
Nissan VQ37VHR (3.7 L) V6 engine: review and specs
Recommended Articles
Article information

Author: Annamae Dooley

Last Updated:

Views: 5793

Rating: 4.4 / 5 (45 voted)

Reviews: 92% of readers found this page helpful

Author information

Name: Annamae Dooley

Birthday: 2001-07-26

Address: 9687 Tambra Meadow, Bradleyhaven, TN 53219

Phone: +9316045904039

Job: Future Coordinator

Hobby: Archery, Couponing, Poi, Kite flying, Knitting, Rappelling, Baseball

Introduction: My name is Annamae Dooley, I am a witty, quaint, lovely, clever, rich, sparkling, powerful person who loves writing and wants to share my knowledge and understanding with you.