#ifndef TFT_DRIVER_H
#define TFT_DRIVER_H
 
#include <Arduino.h>
#include <SPI.h>
#include "hw_config.h"
 
#define TFT_SWRESET   0x01
#define TFT_SLPOUT    0x11
#define TFT_COLMOD    0x3A
#define TFT_MADCTL    0x36
#define TFT_CASET     0x2A
#define TFT_RASET     0x2B
#define TFT_RAMWR     0x2C
#define TFT_DISPON    0x29
#define TFT_DISPOFF   0x28
#define TFT_INVON     0x21
#define TFT_INVOFF    0x20
 
#define DISPLAY_WIDTH  280  
#define DISPLAY_HEIGHT 240
 
#define ST7789_COL_OFFSET 20  <====( affichage prévu initialement pour un ST7789 )
 
#define TFT_BLACK   0x0000
#define TFT_WHITE   0xFFFF
#define TFT_RED     0xF800
#define TFT_GREEN   0x07E0
#define TFT_BLUE    0x001F
 
static const uint8_t font_5x7[] PROGMEM = {
    0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ' '
    0x00, 0x00, 0x5F, 0x00, 0x00, // 0x21 '!'
    0x00, 0x07, 0x00, 0x07, 0x00, // 0x22 '"'
    0x14, 0x7F, 0x14, 0x7F, 0x14, // 0x23 '#'
    0x24, 0x2A, 0x7F, 0x2A, 0x12, // 0x24 '$'
    0x23, 0x13, 0x08, 0x64, 0x62, // 0x25 '%'
    0x36, 0x49, 0x55, 0x22, 0x50, // 0x26 '&'
    0x00, 0x05, 0x03, 0x00, 0x00, // 0x27 '''
    0x00, 0x1C, 0x22, 0x41, 0x00, // 0x28 '('
    0x00, 0x41, 0x22, 0x1C, 0x00, // 0x29 ')'
    0x14, 0x08, 0x3E, 0x08, 0x14, // 0x2A '*'
    0x08, 0x08, 0x3E, 0x08, 0x08, // 0x2B '+'
    0x00, 0x50, 0x30, 0x00, 0x00, // 0x2C ','
    0x08, 0x08, 0x08, 0x08, 0x08, // 0x2D '-'
    0x00, 0x60, 0x60, 0x00, 0x00, // 0x2E '.'
    0x20, 0x10, 0x08, 0x04, 0x02, // 0x2F '/'
    0x3E, 0x51, 0x49, 0x45, 0x3E, // 0x30 '0'
    0x00, 0x42, 0x7F, 0x40, 0x00, // 0x31 '1'
    0x42, 0x61, 0x51, 0x49, 0x46, // 0x32 '2'
    0x21, 0x41, 0x45, 0x4B, 0x31, // 0x33 '3'
    0x18, 0x14, 0x12, 0x7F, 0x10, // 0x34 '4'
    0x27, 0x45, 0x45, 0x45, 0x39, // 0x35 '5'
    0x3C, 0x4A, 0x49, 0x49, 0x30, // 0x36 '6'
    0x01, 0x71, 0x09, 0x05, 0x03, // 0x37 '7'
    0x36, 0x49, 0x49, 0x49, 0x36, // 0x38 '8'
    0x06, 0x49, 0x49, 0x29, 0x1E, // 0x39 '9'
    0x00, 0x36, 0x36, 0x00, 0x00, // 0x3A ':'
    0x00, 0x56, 0x36, 0x00, 0x00, // 0x3B ';'
    0x08, 0x14, 0x22, 0x41, 0x00, // 0x3C '<'
    0x14, 0x14, 0x14, 0x14, 0x14, // 0x3D '='
    0x00, 0x41, 0x22, 0x14, 0x08, // 0x3E '>'
    0x02, 0x01, 0x51, 0x09, 0x06, // 0x3F '?'
    0x32, 0x49, 0x79, 0x41, 0x3E, // 0x40 '@'
    0x7E, 0x11, 0x11, 0x11, 0x7E, // 0x41 'A'
    0x7F, 0x49, 0x49, 0x49, 0x36, // 0x42 'B'
    0x3E, 0x41, 0x41, 0x41, 0x22, // 0x43 'C'
    0x7F, 0x41, 0x41, 0x22, 0x1C, // 0x44 'D'
    0x7F, 0x49, 0x49, 0x49, 0x41, // 0x45 'E'
    0x7F, 0x09, 0x09, 0x09, 0x01, // 0x46 'F'
    0x3E, 0x41, 0x49, 0x49, 0x7A, // 0x47 'G'
    0x7F, 0x08, 0x08, 0x08, 0x7F, // 0x48 'H'
    0x00, 0x41, 0x7F, 0x41, 0x00, // 0x49 'I'
    0x20, 0x40, 0x41, 0x3F, 0x01, // 0x4A 'J'
    0x7F, 0x08, 0x14, 0x22, 0x41, // 0x4B 'K'
    0x7F, 0x40, 0x40, 0x40, 0x40, // 0x4C 'L'
    0x7F, 0x02, 0x0C, 0x02, 0x7F, // 0x4D 'M'
    0x7F, 0x04, 0x08, 0x10, 0x7F, // 0x4E 'N'
    0x3E, 0x41, 0x41, 0x41, 0x3E, // 0x4F 'O'
    0x7F, 0x09, 0x09, 0x09, 0x06, // 0x50 'P'
    0x3E, 0x41, 0x51, 0x21, 0x5E, // 0x51 'Q'
    0x7F, 0x09, 0x19, 0x29, 0x46, // 0x52 'R'
    0x46, 0x49, 0x49, 0x49, 0x31, // 0x53 'S'
    0x01, 0x01, 0x7F, 0x01, 0x01, // 0x54 'T'
    0x3F, 0x40, 0x40, 0x40, 0x3F, // 0x55 'U'
    0x1F, 0x20, 0x40, 0x20, 0x1F, // 0x56 'V'
    0x7F, 0x20, 0x18, 0x20, 0x7F, // 0x57 'W'
    0x63, 0x14, 0x08, 0x14, 0x63, // 0x58 'X'
    0x03, 0x04, 0x78, 0x04, 0x03, // 0x59 'Y'
    0x61, 0x51, 0x49, 0x45, 0x43, // 0x5A 'Z'
    0x00, 0x7F, 0x41, 0x41, 0x00, // 0x5B '['
    0x02, 0x04, 0x08, 0x10, 0x20, // 0x5C '\'
    0x00, 0x41, 0x41, 0x7F, 0x00, // 0x5D ']'
    0x04, 0x02, 0x01, 0x02, 0x04, // 0x5E '^'
    0x40, 0x40, 0x40, 0x40, 0x40, // 0x5F '_'
    0x00, 0x01, 0x02, 0x04, 0x00, // 0x60 '`'
    0x20, 0x54, 0x54, 0x54, 0x78, // 0x61 'a'
    0x7F, 0x48, 0x44, 0x44, 0x38, // 0x62 'b'
    0x38, 0x44, 0x44, 0x44, 0x20, // 0x63 'c'
    0x38, 0x44, 0x44, 0x48, 0x7F, // 0x64 'd'
    0x38, 0x54, 0x54, 0x54, 0x18, // 0x65 'e'
    0x08, 0x7E, 0x09, 0x01, 0x02, // 0x66 'f'
    0x0C, 0x52, 0x52, 0x52, 0x3E, // 0x67 'g'
    0x7F, 0x08, 0x04, 0x04, 0x78, // 0x68 'h'
    0x00, 0x44, 0x7D, 0x40, 0x00, // 0x69 'i'
    0x20, 0x40, 0x44, 0x3D, 0x00, // 0x6A 'j'
    0x7F, 0x10, 0x28, 0x44, 0x00, // 0x6B 'k'
    0x00, 0x41, 0x7F, 0x40, 0x00, // 0x6C 'l'
    0x7C, 0x04, 0x18, 0x04, 0x78, // 0x6D 'm'
    0x7C, 0x08, 0x04, 0x04, 0x78, // 0x6E 'n'
    0x38, 0x44, 0x44, 0x44, 0x38, // 0x6F 'o'
    0x7C, 0x14, 0x14, 0x14, 0x08, // 0x70 'p'
    0x08, 0x14, 0x14, 0x18, 0x7C, // 0x71 'q'
    0x7C, 0x08, 0x04, 0x04, 0x08, // 0x72 'r'
    0x48, 0x54, 0x54, 0x54, 0x20, // 0x73 's'
    0x04, 0x3F, 0x44, 0x40, 0x20, // 0x74 't'
    0x3C, 0x40, 0x40, 0x20, 0x7C, // 0x75 'u'
    0x1C, 0x20, 0x40, 0x20, 0x1C, // 0x76 'v'
    0x3C, 0x40, 0x30, 0x40, 0x3C, // 0x77 'w'
    0x44, 0x28, 0x10, 0x28, 0x44, // 0x78 'x'
    0x0C, 0x50, 0x50, 0x50, 0x3C, // 0x79 'y'
    0x44, 0x64, 0x54, 0x4C, 0x44, // 0x7A 'z'
    0x00, 0x08, 0x36, 0x41, 0x00, // 0x7B '{'
    0x00, 0x00, 0x7F, 0x00, 0x00, // 0x7C '|'
    0x00, 0x41, 0x36, 0x08, 0x00, // 0x7D '}'
    0x10, 0x08, 0x08, 0x10, 0x08, // 0x7E '~'
    0x00, 0x00, 0x00, 0x00, 0x00  // 0x7F DEL
};
 
class TFTDriver {
private:
    static constexpr int TFT_DC = 15;
    static constexpr int TFT_RST = 9;
    static constexpr int TFT_CS = 10;
    static constexpr int TFT_SCK = 12;
    static constexpr int TFT_MOSI = 11;
    static constexpr int TFT_MISO = -1;
 
    void spi_write_cmd(uint8_t cmd) {
        digitalWrite(TFT_CS, LOW);
        digitalWrite(TFT_DC, LOW);  
        SPI.write(cmd);
        digitalWrite(TFT_DC, HIGH);
        digitalWrite(TFT_CS, HIGH);
    }
 
    void spi_write_byte(uint8_t data) {
        digitalWrite(TFT_CS, LOW);
        digitalWrite(TFT_DC, HIGH);  
        SPI.write(data);
        digitalWrite(TFT_CS, HIGH);
    }
 
    void spi_write_word(uint16_t data) {
        digitalWrite(TFT_CS, LOW);
        digitalWrite(TFT_DC, HIGH); 
        SPI.write16(data);
        digitalWrite(TFT_CS, HIGH);
    }
  public:
    TFTDriver() {}
 
    void init() {
        pinMode(TFT_DC, OUTPUT);
        pinMode(TFT_RST, OUTPUT);
        pinMode(TFT_CS, OUTPUT);
 
        digitalWrite(TFT_CS, HIGH);
        digitalWrite(TFT_DC, HIGH);
 
        SPI.begin(TFT_SCK, TFT_MISO, TFT_MOSI, TFT_CS);
        SPI.setFrequency(80000000);
	//SPI.setFrequency(40000000);
        SPI.setDataMode(SPI_MODE0);
        SPI.setBitOrder(MSBFIRST);
 
        digitalWrite(TFT_RST, HIGH);
        delay(30);
        digitalWrite(TFT_RST, LOW);
        delay(30);
        digitalWrite(TFT_RST, HIGH);
        delay(30);
 
        spi_write_cmd(TFT_SWRESET);
        delay(30);
 
        spi_write_cmd(TFT_SLPOUT);
        delay(50);
 
        spi_write_cmd(TFT_COLMOD);
        spi_write_byte(0x55);  
 
        delay(5);
 
        spi_write_cmd(TFT_MADCTL);
        //spi_write_byte(0x60);  // Landscape: rotate 90°        <====== valeur d'origine 
	spi_write_byte(0x70);  // <==== test 
        delay(5);
 
        spi_write_cmd(TFT_CASET);
        spi_write_cmd(TFT_RASET);
        delay(5);
 
        fillScreen(TFT_BLACK);
        delay(20);
 
        spi_write_cmd(TFT_DISPON);
        delay(50);
 
        spi_write_cmd(TFT_INVOFF);
        delay(10);
 
    }
 
    void fillScreen(uint16_t color) {
        spi_write_cmd(TFT_CASET);
        spi_write_word(ST7789_COL_OFFSET);
        spi_write_word(ST7789_COL_OFFSET + DISPLAY_WIDTH - 1);
 
        spi_write_cmd(TFT_RASET);
        spi_write_word(0);
        spi_write_word(DISPLAY_HEIGHT - 1);
 
        spi_write_cmd(TFT_RAMWR);
 
        digitalWrite(TFT_CS, LOW);
        digitalWrite(TFT_DC, HIGH);  
 
        uint32_t pixel_count = (uint32_t)DISPLAY_WIDTH * DISPLAY_HEIGHT;
        static uint8_t buffer[512];  
 
        uint8_t high = color >> 8;
        uint8_t low = color & 0xFF;
        for (int i = 0; i < 512; i += 2) {
            buffer[i] = high;
            buffer[i + 1] = low;
        }
 
        for (uint32_t i = 0; i < pixel_count; i += 256) {
            uint32_t chunk_size = (pixel_count - i > 256) ? 256 : (pixel_count - i);
            SPI.writeBytes(buffer, chunk_size * 2);
        }
 
        digitalWrite(TFT_CS, HIGH);
    }
 
    void pushImage(int x, int y, int w, int h, const uint16_t *data, bool preswapped = false) {
 
        spi_write_cmd(TFT_CASET);
        spi_write_word(x + ST7789_COL_OFFSET);
        spi_write_word(x + w - 1 + ST7789_COL_OFFSET);
 
        spi_write_cmd(TFT_RASET);
        spi_write_word(y);
        spi_write_word(y + h - 1);
 
        spi_write_cmd(TFT_RAMWR);
 
        digitalWrite(TFT_CS, LOW);
        digitalWrite(TFT_DC, HIGH);  
 
        uint32_t pixel_count = (uint32_t)w * h;
 
        static uint8_t buffer[1024];  
 
        for (uint32_t i = 0; i < pixel_count; i += 512) {
            uint32_t chunk_size = (pixel_count - i > 512) ? 512 : (pixel_count - i);
            if (preswapped) { 
                SPI.writeBytes((const uint8_t *)&data[i], chunk_size * 2);
            } else {
                for (uint32_t j = 0; j < chunk_size; j++) {
                    uint16_t pixel = data[i + j];
                    buffer[j * 2] = pixel >> 8;      
                    buffer[j * 2 + 1] = pixel & 0xFF;  
                }
                SPI.writeBytes(buffer, chunk_size * 2);
            }
        }
 
        digitalWrite(TFT_CS, HIGH);
    } 
    void drawChar(int x, int y, char c, uint16_t fg, uint16_t bg, int scale = 1) {
        if (scale < 1) {
            scale = 1;
        }
 
        uint8_t idx = (c >= 0x20 && c <= 0x7F) ? static_cast<uint8_t>(c - 0x20) : static_cast<uint8_t>('?' - 0x20);
        const uint8_t *glyph = &font_5x7[idx * 5];
 
        for (int cy = 0; cy < 7; cy++) {
            for (int cx = 0; cx < 5; cx++) {
                uint8_t line = pgm_read_byte(&glyph[cx]);
                if (line & (1 << cy)) {
                    drawFilledRect(x + cx * scale, y + cy * scale, scale, scale, fg);
                } else {
                    drawFilledRect(x + cx * scale, y + cy * scale, scale, scale, bg);
                }
            }
        }
    }
 
    void drawFilledRect(int x, int y, int w, int h, uint16_t color) {
        if (w <= 0 || h <= 0) {
            return;
        }
 
        int x0 = max(0, x);
        int y0 = max(0, y);
        int x1 = min(DISPLAY_WIDTH - 1, x + w - 1);
        int y1 = min(DISPLAY_HEIGHT - 1, y + h - 1);
 
        if (x1 < x0 || y1 < y0) {
            return;
        }
 
        int clipped_w = x1 - x0 + 1;
        int clipped_h = y1 - y0 + 1;
 
        spi_write_cmd(TFT_CASET);
        spi_write_word(x0 + ST7789_COL_OFFSET);
        spi_write_word(x1 + ST7789_COL_OFFSET);
 
        spi_write_cmd(TFT_RASET);
 
        spi_write_word(y0);
        spi_write_word(y1);
 
        spi_write_cmd(TFT_RAMWR);
 
        digitalWrite(TFT_CS, LOW);
        digitalWrite(TFT_DC, HIGH);
 
        uint32_t pixels = (uint32_t)clipped_w * clipped_h;
 
        for (uint32_t i = 0; i < pixels; i++) {
             SPI.write16(color);
        }
 
         digitalWrite(TFT_CS, HIGH);
    }
 
    void drawNumber(int x, int y, int num, uint16_t fg, uint16_t bg, int scale = 1) {
        if (num < 0) num = 0;
        char buf[10];
        sprintf(buf, "%d", num);
 
        int px = x;
        for (int i = 0; buf[i] != '\0'; i++) {
            drawChar(px, y, buf[i], fg, bg, scale);
            px += (5 + 1) * scale; 
        }
    }
 
    void drawString(int x, int y, const char *str, uint16_t fg, uint16_t bg, int scale = 1) {
        int px = x;
        for (int i = 0; str[i] != '\0'; i++) {
            drawChar(px, y, str[i], fg, bg, scale);
            px += (5 + 1) * scale;  
            }
        }
 
        static uint16_t color565(uint8_t r, uint8_t g, uint8_t b) {
        return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
        }
   };
#endif

 
spi_write_cmd(TFT_MADCTL);
        //spi_write_byte(0x60);  // Landscape: rotate 90°
	spi_write_byte(0x70);  //
        delay(5);

 
/***************************************
          ESP32C3 Mini
          adresse IP:192.168.1.150
          Version : Test_V20260422a
          
                         _____
                   |----|     |-----|
                   |    |_____|     |
           GPIO5   | 5           5V | 
    E-SDA  GPIO6   | 6            G | 
       CS  GPIO7   | 7          3V3 |    
  AHT-SDA  GPIO8   | 8            4 | GPIO4     E-SCL
  AHT-SCL  GPIO9   | 9            3 | GPIO3     BUSY
   DS18B20 GPIO10  | 10           2 | GPIO2     RES
           GPIO20  | 20           1 | GPIO1     DC
           GPIO21  | 21           0 | GPIO0     VBat
                   \------------- --/
                           
*************************************/
 
#include <WiFi.h>
#include <Wire.h>
#include <ArduinoOTA.h>
#include <Arduino.h>
#include <PubSubClient.h>
#include "BitmapGraphics.h"
#include "Batteriefaible.h"
#include <functional>
#include <Wire.h>
#include <AHT20.h>  //<=======================
 
#include <OneWire.h>
#include <DallasTemperature.h>
#include "config.h"
 
 
#include <MQTT.h>
 
char server[] = "mqtt3.thingspeak.com";
 
//  E-paper *********************************************
#include <GxEPD2_BW.h>
#include <GxEPD2_GFX.h>
#include <Fonts/FreeMonoBold9pt7b.h>
#include "FreeSerifBold30pt7b.h"
// 2.9" EPD Module
//#define ENABLE_GxEPD2_display 0
#define SCREEN_WIDTH   296
#define SCREEN_HEIGHT  128
#define Large 7    // For best results use odd numbers
#define Small 3    // For best results use odd numbers
static const uint8_t EPD_SCL = 4; // Master-In Slave-Out not used, as no data from display
static const uint8_t EPD_SDA = 6; // to EPD DIN
GxEPD2_BW<GxEPD2_290_BS, GxEPD2_290_BS::HEIGHT> display(GxEPD2_290_BS(/*CS=7*/ SS, /*DC=*/ 1, /*RES=*/ 2, /*BUSY=*/ 3)); // DEPG0290BS 128x296, SSD1680
 
//*******************************************************
#define aht10 0x38 //adresse 0x38 ou 0x39
//*******************************************************
#if DEBUG
#define D_SerialBegin(...) Serial.begin(__VA_ARGS__)
#define D_print(...) Serial.print(__VA_ARGS__)
#define D_write(...) Serial.write(__VA_ARGS__)
#define D_println(...) Serial.println(__VA_ARGS__)
#define D_printf(...) Serial.printf(__VA_ARGS__)
#define D_flush(...) Serial.flush(__VA_ARGS__)
#define D_timestamp() Serial.printf("[%lu] ", millis())
#else
#define D_SerialBegin(bauds)
#define D_print(...)
#define D_write(...)
#define D_println(...)
#define D_printf(...)
#define D_flush(...)
#define D_timestamp()
#endif
 
#ifndef DEBUG
#define DEBUG 0 /**< Régler à 1 pour déboguer en série */
#endif
 
//*******************************************************
const byte oneWireBus = 10;  // DS18B20 pin used for Temperature sensor bus GIPO10
float humidity;
float temperature;
char temp[10];
char bat[10];
float piscine;
const gpio_num_t vbatPin = GPIO_NUM_0;
uint_fast16_t Vbatt ;
float batteryVoltage;
int8_t batteryPercentage;
uint_fast16_t adcValue;
char error[15];
uint8_t wifiRetries = 0;
 
bool isWifiStarted = false;
bool isWifiReady = false;
bool isRegularWifi = false;
bool isMQTTStarted = false;
bool isMQTTReady = false;
bool isRtcValid = false;
 
 
//*********** Init **************************
WiFiClient  wifiClient;
WiFiServer serverAP(80);
PubSubClient pubSubclient(wifiClient);
OneWire oneWire(oneWireBus);
DallasTemperature sensors(&oneWire);
 
//****    AHT20 ******************************
AHT20 aht; //<=========================
bool status_aht = false;
 
 
//******************************************************** 
struct __attribute__((packed, aligned(1))) WiFiRapide {
  uint8_t channel;
  uint8_t ap_mac[6];
  uint32_t crc32;
};
 
RTC_DATA_ATTR WiFiRapide rtcData = {0, {0, 0, 0, 0, 0, 0}, 0xDEADBEEF}; 
uint32_t calculateCRC32MPGE2(const uint8_t *data, size_t length) {
  uint32_t crc = 0xffffffff;
  while (length--) {
    uint8_t c = *data++;
    for (uint32_t i = 0x80; i > 0; i >>= 1) {
      bool bit = crc & 0x80000000;
      if (c & i) bit = !bit;
      crc <<= 1;
      if (bit) crc ^= 0x04c11db7;
    }
  }
  return crc;
}
 
void printByte(uint8_t b) {
  Serial.print("0x");
  if (b < 0x10) Serial.write('0');
  Serial.print(b, HEX);
}
 
void printStructure(WiFiRapide& s) {
  Serial.print("channel = "); Serial.println(s.channel);
  Serial.print("ap_mac[] = ");
  for (uint8_t i = 0; i < sizeof(s.ap_mac); i++) {
    printByte(s.ap_mac[i]);
    Serial.write(' ');
  }
  Serial.println();
  Serial.print("CRC32-MPEG2 = 0x"); Serial.println(s.crc32, HEX);
}
unsigned long startMillis;
 
//*****************************************
// SETUP
//****************************************
 
void setup()
{  	
	delay(1000); // il sert surtout au premier boot pour qu'on le voit sur le moniteur série
	D_SerialBegin(115200);
	while (!Serial) yield();
	//Serial.print("Taille de la structure = "); Serial.print(sizeof rtcData); Serial.println(" octets.");
 
	esp_reset_reason_t resetReason = esp_reset_reason();
	if (resetReason != ESP_RST_DEEPSLEEP) {
		Serial.println("Premier boot");
	} else {
		Serial.println("Reboot sur timer");
	}
 
	// on vérifie si ce qu'on avait dans la mémoire était correct (ce ne sera pas le cas au boot)
	uint32_t crcAttendu = calculateCRC32MPGE2((uint8_t*)&rtcData, sizeof rtcData - sizeof(uint32_t));
	bool isRtcValid = (rtcData.crc32 == crcAttendu);
 
	//Serial.print("crcAttendu = 0x"); Serial.println(crcAttendu, HEX);
	//Serial.print("crc en mémoire RTC = 0x"); Serial.println(rtcData.crc32, HEX);
 
 
    //**** INIT Ecran E-paper**********
    display.init(115200,true,50,false);
    display.setRotation(3);
    display.setFullWindow();
    display.fillScreen(GxEPD_BLACK);
    display.drawBitmap(0, 0, gImage_gui, 296, 128, GxEPD_WHITE);
    while (display.nextPage()); 
    delay(500) ;     
 
    //********** VBAT ********************
	  pinMode(0, INPUT); // Pin Entree VBAT
    // *** DS18B20 Temperature sensor ****
    sensors.begin(); 
    // **** AHT20 *************
     Wire.begin();
    if (aht.begin() == false)
    {
      Serial.println("AHT20 not detected. Please check wiring. Freezing.");
      while(true);
    }
 
    // Wait minimum sampling period
    startMillis = millis();
 
    //---------------------------------------------
    // Step 0:
    // Lecture DS18B20
    //---------------------------------------------
 
       sensors.requestTemperatures(); 
       float raw_temp = sensors.getTempCByIndex(0);
       piscine = sensors.getTempCByIndex(0);
       Serial.printf("Temperature = %8.4f°C\r\n", (float)raw_temp);
       snprintf(temp, sizeof temp, "%.1f",(float)raw_temp);
       updatePiscine();
 
    //---------------------------------------------
    // Step 1: Lecture de la température et de l'humidité à partir de AHT20
    //---------------------------------------------
 
        temperature = aht.getTemperature();
        humidity = aht.getHumidity();
        D_timestamp();
        D_println("AHT20 Reading ready");
        D_timestamp();
        D_printf("Temperature: %.1f, Humidity: %.1f ", temperature, humidity);
        D_println();
 
    //---------------------------------------------
    // Step 2: Lecture Batterie ADC GPIO0
    //---------------------------------------------
 
        adcValue =  analogReadMilliVolts(vbatPin); //<============
        uint_fast16_t Vbatt = 0;
        for(int i = 0; i < 16; i++) {
         Vbatt = Vbatt + adcValue ;// ADC with correction   
        }
        batteryVoltage = 2 * Vbatt / 16 / 1000.00;     // attenuation ratio 1/2, mV --> V
        batteryPercentage = ((batteryVoltage-3.20)*100.0); // 
 
 
        int tensionBrute = adcValue ; 
        constexpr int seuilTensionBruteBasse = 1600; // 3.2V ==> calculé par (3.2V / 2) 
        if  (tensionBrute <= seuilTensionBruteBasse)
        {
            if (batteryPercentage < 0){
              (batteryPercentage = 0) ;
            } 
            D_timestamp();
            D_println("Batterie faible. Sommeil profond.");
            D_printf("Battery Percentage: %i", batteryPercentage);
            batteriefaible();
            //esp_sleep_enable_timer_wakeup(120000000ULL); // on programme un réveil pour dans 120s (en µs)
        }
 
 
          D_timestamp();
          D_printf("Vbat: %.2f",batteryVoltage);
          D_println();
          sprintf(bat, "%3d%s", batteryPercentage, "%");
          updateBattery() ;
 
 
    //---------------------------------------------
    // Step 3: Demarrage Connection WIFI
    //---------------------------------------------
 
      D_timestamp();
      D_println("Démarrage du WiFi");
      WiFi.mode(WIFI_STA);
 
 
      if (isRtcValid) {
        Serial.print("Connexion RAPIDE au Wi-Fi en cours...");
        WiFi.begin(WLAN_SSID, WLAN_PASSWD, rtcData.channel, rtcData.ap_mac, true);
      } else {
        Serial.print("Connexion LENTE au Wi-Fi en cours...");
        WiFi.begin(WLAN_SSID, WLAN_PASSWD);
      }
 
      isWifiStarted = true;
 
 
    //---------------------------------------------
    // Step 4: Si le WiFi est prêt : Initialiser le client MQTT
    //---------------------------------------------
 
    if (isWifiStarted)
    {
 
  		while (WiFi.status() != WL_CONNECTED) 
  		{
  		Serial.write('.');
  		delay(500);
      }
 
  	  Serial.println(" => Connecté");
  	  Serial.print("adresse IP:");   Serial.println(WiFi.localIP());
      isWifiReady = true;
 
      if (isWifiReady) 
      {	
        /*  
        pubSubclient.setServer(server, 1883);
        D_timestamp();
        pubSubclient.connect(MQTT_CLIENT, MQTT_USER, MQTT_PASSWORD);
        delay(10);
        D_timestamp();
        D_println("MQTT connected");
        pubSubclient.loop();
        D_print("MQTT Publish: ");
        D_println(MQTT_TOPIC);
        String topicString ="channels/" + String(MQTT_TOPIC) + "/publish";
        String dataString = String("field1=" + String(temperature) + "&field2=" + String(humidity) + "&field3=" + String(batteryPercentage) + "&field4=" + String(piscine)+"&timezone=Europe/Paris");
        pubSubclient.publish(topicString.c_str(),dataString.c_str());
        delay(100);
  
          // si la mémoire RTC n'était pas valide, on la met à jour pour le prochain réveil
        if (!isRtcValid) {
            rtcData.channel = WiFi.channel();
            memcpy(rtcData.ap_mac, WiFi.BSSID(), 6); // les 6 octets de l'adresse mac
            // puis on met à jour le CRC dans la structure
            rtcData.crc32 = calculateCRC32MPGE2((uint8_t*)&rtcData, sizeof rtcData - sizeof(uint32_t));
            Serial.println(" Sauv config pour la prochaine fois en mémoire RTC. ");
            printStructure(rtcData);
        }
        */
 
	      if  (tensionBrute > seuilTensionBruteBasse)
        {	
          D_timestamp();
          D_println("Batterie OK. Dormir....");
          D_printf("Battery Percentage: %i", batteryPercentage);	
		      Serial.flush();
 		      esp_sleep_enable_timer_wakeup(60000000ull); // on programme un réveil pour dans 1mn (en µs) pour test
          //esp_sleep_enable_timer_wakeup(18000000000ull); // on programme un réveil pour dans 30mn (en µs)
		    } else{
			    D_timestamp();
          D_println("Batterie faible. Sommeil profond.");
          D_printf("Battery Percentage: %i", batteryPercentage);
          Serial.flush();
          //esp_sleep_enable_timer_wakeup(60000000ull); // on programme un réveil pour dans 1mn (en µs) pour test
 		      //esp_sleep_enable_timer_wakeup(3600000000ull); // on programme un réveil pour dans 1h (en µs)
		    }	
      }  
	  }
 
   esp_deep_sleep_start();  
 
}
 
 
//**************************************
//  LOOP
//**************************************
void loop() {}
 
 
//*******************************************************
void updateBattery() 
{
  int16_t tbx, tPar;
  uint16_t tbw, tbh;
  display.setRotation(3);
  display.setFont(&FreeMonoBold9pt7b);
  display.setTextColor(GxEPD_BLACK);
  uint16_t x = 225;
  uint16_t y = 120;
  display.getTextBounds(bat, x, y, &tbx, &tPar, &tbw, &tbh);
  display.setPartialWindow(tbx, tPar, tbw, tbh);
  display.firstPage();
  do {
    //display.fillScreen(GxEPD_WHITE);
    display.setCursor(x, y);
    display.print(bat);
  } while (display.nextPage());
  delay(500);
 
}
 
 
//*******************************************************
void updatePiscine() 
{
  int16_t tbx, tPar;
  uint16_t tbw, tbh;
  display.setRotation(3);
  display.setFont(&FreeSerifBold30pt7b);
  display.setTextColor(GxEPD_BLACK);
  uint16_t x = 120;
  uint16_t y = 80;
  display.getTextBounds(temp, x, y, &tbx, &tPar, &tbw, &tbh);
  display.setPartialWindow(tbx, tPar, tbw, tbh);
  display.firstPage();
  do {
    display.fillScreen(GxEPD_WHITE);
    display.setCursor(x, y);
    display.print(temp);
  } while (display.nextPage());
   delay(500);
}
 
 
void batteriefaible() {
 display.setRotation(3);
    display.setFullWindow();
    display.fillScreen(GxEPD_BLACK);
    display.drawBitmap(0, 0, myBitmapbatterie_faible, 296, 128, GxEPD_WHITE);
    while (display.nextPage()); 
    delay(500) ;     
 
}

#include "HX710B.h"
 
const int DOUT = 2;
const int CLK_PIN = 3;
 
HX710B sensor;
 
void setup() {
  Serial.begin(115200);
  sensor.begin(DOUT, CLK_PIN);
}
 
void loop() {
  if (sensor.is_ready()) {
    Serial.print("mmHg: ");
    Serial.print(sensor.mmHg());
 
    Serial.print(" | PSI: ");
    Serial.println(sensor.psi());
  } else {
    Serial.println("Sensor not ready");
  }
 
  delay(1000);
}

 
   if (TEMPS==10.00)digitalWrite(A1, HIGH);
   if (A2, HIGH) digitalWrite(A2, LOW);
   if (A3, HIGH)digitalWrite(A3, LOW);
   if (A4, HIGH)digitalWrite(A4, LOW);   
 
 
   if (TEMPS==15.00)digitalWrite(A2, HIGH);
   if (A1,HIGH)digitalWrite(A1, LOW);
   if (A3,HIGH)digitalWrite(A3, LOW);
   if (A4,HIGH)digitalWrite(A4, LOW);  
 
 
  if (TEMP==20.00) digitalWrite(A3, HIGH);
  if (A1, HIGH)digitalWrite(A1, LOW);
  if (A2, HIGH)digitalWrite(A2, LOW);
  if (A4, HIGH)digitalWrite(A4, LOW);
 
 
  if (TEMP==25.00) digitalWrite(A4, HIGH);
  if (A1, HIGH)digitalWrite(A1, LOW);
  if (A2, HIGH)digitalWrite(A2, LOW);
  if (A3, HIGH)digitalWrite(A3, LOW);

 
 
const char* jours[] = {
  "Dim","Lun","Mar","Mer",
  "Jeu","Ven","Sam"
};
 
const char* mois[] = {
  "Janv","Fev","Mars","Avr","Mai","Jun",
  "Jul","Aout","Sept","Oct","Nov","Dec"
};
 
.../...
 
void drawClock() {
  setlocale(LC_TIME,""); 
  struct tm t;
 
  if (!getLocalTime(&t)) {
    display.setFont(NULL);
    display.setCursor(30, 30);
    display.print("Synchro en cours...");
    return;
  }
 
  int h12 = t.tm_hour ;
  display.setTextColor(SSD1306_WHITE);
  display.setFont(NULL);
  display.setTextSize(1);
  display.setCursor(114, 0);
  //display.print(ampm);
  display.setFont(&FreeSansBold18pt7b);
  char timeStr[6];
  sprintf(timeStr, "%02d:%02d", h12, t.tm_min);
  int16_t x1, y1;
  uint16_t w, h;
  display.getTextBounds(timeStr, 0, 0, &x1, &y1, &w, &h);
  display.setCursor((SCREEN_WIDTH - w) / 2, 42);
  display.print(timeStr);
  display.setFont(&FreeSans9pt7b);
  const char* j =jours[t.tm_wday];  
  const char* m =mois[t.tm_mon];
  char dateStr[20];
  strftime(dateStr, 20, "%j %d %m", &t);
  display.getTextBounds(dateStr, 0, 0, &x1, &y1, &w, &h);
  display.setCursor((SCREEN_WIDTH - w) / 2, 62);
  display.print(dateStr);
}

 
/01d32.jpg
../..
/alarm.txt
/config.txt  <=====================
/ik.txt
/i_stat.txt
/wind_2.jpg
/wind_4.jpg
/wind_6.jpg
/wind_8.jpg
[SPIFFS] upload  : C:\Users\UTILIS~1\AppData\Local\Temp\arduino_build_795945/meteoV12.spiffs.bin
[SPIFFS] address  : 0x200000
[SPIFFS] reset    : nodemcu
[SPIFFS] port     : COM4
[SPIFFS] speed    : 921600
 
Uploading 2076672 bytes from C:\Users\UTILIS~1\AppData\Local\Temp\arduino_build_795945/meteoV12.spiffs.bin to flash at 0x00200000
................................................................................ [  3% ]
................................................................................ [  7% ]
................................................................................ [ 11% ]
................................................................................ [ 15% ]
................................................................................ [ 19% ]
................................................................................ [ 23% ]
................................................................................ [ 27% ]
................................................................................ [ 31% ]
................................................................................ [ 35% ]
................................................................................ [ 39% ]
................................................................................ [ 43% ]
................................................................................ [ 47% ]
................................................................................ [ 51% ]
................................................................................ [ 55% ]
................................................................................ [ 59% ]
................................................................................ [ 63% ]
................................................................................ [ 67% ]
................................................................................ [ 71% ]
................................................................................ [ 74% ]
................................................................................ [ 78% ]
................................................................................ [ 82% ]
................................................................................ [ 86% ]
................................................................................ [ 90% ]
................................................................................ [ 94% ]
................................................................................ [ 98% ]
............................                                                     [ 100% ]

 
meteoV12:184:22: fatal error: LittleFS.h: No such file or directory
 #include <LittleFS.h>  <===================================
                      ^
compilation terminated.
Plusieurs bibliothèque trouvées pour "WiFiClient.h"
Utilisé : C:\Users\Utilisateur\Documents\ArduinoData\packages\esp8266\hardware\esp8266\2.5.0\libraries\ESP8266WiFi
Non utilisé : C:\Users\Utilisateur\Documents\Arduino\libraries\WiFi101
Non utilisé : C:\Program Files\WindowsApps\ArduinoLLC.ArduinoIDE_1.8.57.0_x86__mdqgnx93n4wtt\libraries\WiFi
exit status 1
LittleFS.h: No such file or directory

 
/*************************************
             EMETTEUR
**************************************/
 
 
/***************************************
          ESP32 WROOM LOW POWER DEVKIT
          uPesy
                   ------------------
                   |1             32| GPIO23   MOSI
                   |2             31|
                   |3             30|
                   |4             29|
                   |5             28|
  DATA    GPIO32   |6             27| GPIO19   MISO
                   |7             26| GPIO18   SCK 
                   |8             25| 
                   |9             24| 
  DIO0     GPIO27  |10            23|
  RST      GPIO14  |11            22|  
                   |12            21| 
  NSS      GPIO13  |13            20|  
                   |14            19|
                   |15            18| 3V3 VCC
                   |16     |----| 17| GND
                   \-------|    |---/
                           |----| 
*************************************/
#include <driver/rtc_io.h>
#include <LoRa.h>
#include <SPI.h>
 
// LoRa definition
#define SCK     18   // GPIO18 -- SX1278's SCK
#define MISO    19   // GPIO19 -- SX1278's MISO
#define MOSI    23   // GPIO23 -- SX1278's MOSI
#define SS      5    // GPIO5  -- SX1278's NSS
#define RST     14   // GPIO14 -- SX1278's RST
#define DI0     27   // GPIO27 -- SX1278's IRQ(Interrupt Request)
 
#define LORA_SS_GPIO_NUM  GPIO_NUM_5
#define LORA_RST_GPIO_NUM GPIO_NUM_14
 
#define BAND 433E6  //433E6 for Asia, 866E6 for Europe and 915E6 for North America
 
const gpio_num_t pinBAL    = GPIO_NUM_32; // RTC GPIO for ESP32: 0, 2, 4, 12-15, 25-27, 32-39;
const gpio_num_t vbatPin   = GPIO_NUM_35;
 
//#define BUTTON_PIN_BITMASK (1ull << pinBAL) // 
const uint64_t  uS_TO_S_FACTOR = 1000000ull; /* Facteur de conversion des microsecondes en secondes */
const uint64_t  TIME_TO_SLEEP = 300ull; /* Temps de mise en veille de l'ESP32 (en secondes) ici 5Mn */
 
RTC_DATA_ATTR int bootCount = 0;
RTC_DATA_ATTR int Vbat = 0;
 
int vBat;
#define DELTA 32
 
//***********************************************
void loraMessage(const char * message) {
  LoRa.beginPacket();
  LoRa.println(message);
  LoRa.endPacket();
}
 
 
void envoiVbatBrut() {
   char str[8];                                  // 6 caractères devraient suffire : V4095 et /0
   int  cmpt = 8;
   int vBatOld = 0 ; 
   do {
      cmpt--;
	  vBatOld = vBat;
	  vBat = analogRead(vbatPin); // tension échantillonnée brute
   } while((abs(vBat-vBatOld) > DELTA) && (cmpt > 0));
   Serial.print("Valeur Brute = "); 
   Serial.println(vBat);
   sprintf(str, "V%d", vBat);                    // 'V' suivi de la tension brute 
   loraMessage(str);                             // Envoi du message
} 
 
 
//***********************************************
void action() {
  esp_sleep_wakeup_cause_t source_reveil = esp_sleep_get_wakeup_cause();
  uint64_t GPIO_reason = esp_sleep_get_ext1_wakeup_status();
 
  switch (source_reveil) {
    case ESP_SLEEP_WAKEUP_TIMER :
      Serial.println("Réveil par un timer");
      envoiVbatBrut();
      break;
    default :
      Serial.print("Aucun Réveil causé par le Deep Sleep :");
      Serial.println(source_reveil);
      break;
  }
 
  if (GPIO_reason != 0) {
    const uint64_t gpioWakeUp = __builtin_ctzll(GPIO_reason); // __builtin_ctzll finds the position of the rightmost 1
    switch (gpioWakeUp) {
      case pinBAL: loraMessage("1"); break;
      default : Serial.println("Aucun GPIO connu n'a déclenché le réveil"); break;
    }
  }
}
 
//***********************************************
//   SETUP
//***********************************************   
 
void setup() {
  rtc_gpio_hold_dis(LORA_SS_GPIO_NUM);
  rtc_gpio_hold_dis(LORA_RST_GPIO_NUM); 
 
  Serial.begin(115200);
  while (!Serial) yield();
 
  SPI.begin(SCK, MISO, MOSI, SS);
  LoRa.setPins(SS, RST, DI0);
 
  Serial.println("LoRa : Emetteur");
  if (!LoRa.begin(BAND)) { // LoRa_frequency
    Serial.println("Le lancement de LoRa a échoué !");
    while (true) yield();
  }
  Serial.println("init ok");
 
  //Incrémenter le numéro de démarrage et l'imprimer à chaque redémarrage
  ++bootCount;
  Serial.print("Boot number: ");  Serial.println(bootCount);
 
  //action();
 
  // go back to sleep
  //LoRa.end();
  //delay(600);
  LoRa.sleep();
 
  digitalWrite(SS, HIGH); // Normalement la broche est déjà à l'état haut
  rtc_gpio_hold_en(LORA_SS_GPIO_NUM);
 
  digitalWrite(RST, HIGH); // Normalement la broche est déjà à l'état haut
  rtc_gpio_hold_en(LORA_RST_GPIO_NUM);
 
 
 
 // esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK, ESP_EXT1_WAKEUP_ANY_HIGH);
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
 
 
  //Serial.println("Going to sleep");
  Serial.flush(); // esp_deep_sleep_start() va vider le contenu des FIFO UART
  esp_deep_sleep_start();
}
 
//***********************************************
//   LOOP
//***********************************************
 
void loop() {}

10:42:48.418 -> ets Jul 29 2019 12:21:46
10:42:48.418 -> 
10:42:48.418 -> rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
10:42:48.418 -> configsip: 0, SPIWP:0xee
10:42:48.418 -> clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
10:42:48.418 -> mode:DIO, clock div:2
10:42:48.418 -> load:0x3fff0030,len:4876
10:42:48.418 -> ho 0 tail 12 room 4
10:42:48.418 -> load:0x40078000,len:16600
10:42:48.418 -> ho 0 tail 12 room 4
10:42:48.418 -> load:0x40080400,len:3500
10:42:48.418 -> entry 0x400805b4
10:42:48.530 -> E (6) R�CLoRa : Emetteur
10:42:48.530 -> Le lancement de LoRa a échoué !

 
compilation terminated.
exit status 1
driver/rtc_io.h: No such file or directory

 
e croquis utilise 297700 octets (22%) de l'espace de stockage de programmes. Le maximum est de 1310720 octets.
Les variables globales utilisent 22308 octets (6%) de mémoire dynamique, ce qui laisse 305372 octets pour les variables locales. Le maximum est de 327680 octets.

 
#include <VarSpeedServo.h>
#include <Adafruit_SSD1306.h>
 
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
//Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire);
 
#include <FluxGarage_RoboEyes.h>
roboEyes roboEyes; 
 
VarSpeedServo leftArm;
VarSpeedServo rightArm;
 
//Servo Variables
unsigned long previousMillis = 0;  // Stores last time action was performed
unsigned long interval = 100; //Default interval
bool armMovingUp = true;
 
//Animation Variables
bool happyActivate = false;
int happyCycle = 0;
 
bool sadActivate = false;
int sadCycle = 0;
 
bool angryActivate = false;
int angryCycle = 0;
 
bool confusedActivate = false;
int confusedCycle = 0;
 
bool laughActivate = false;
int laughCycle = 0;
 
bool waveActivate = false;
int waveCycle = 0;
 
bool danceActivate = false;
int danceCycle = 0;
 
bool nodActivate = false;
int nodCycle = 0;
 
bool pointActivate = false;
int pointCycle = 0;
 
// Idle delay
unsigned long startTime = 0; // variable to store the start time
bool idleModeActive = false;
bool idleCount = false;
 
 
void setup() {
  Serial.begin(9600);
  // OLED Display
  // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3C or 0x3D
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }
 
  // Startup robo eyes
  roboEyes.begin(SCREEN_WIDTH, SCREEN_HEIGHT, 100); // screen-width, screen-height, max framerate - 60-100fps are good for smooth animations
  roboEyes.setWidth(40, 40);
  roboEyes.setHeight(40, 40);
  roboEyes.close(); // start with closed eyes       
 
  // Initialize servos
  leftArm.attach(A3); // Attach left arm servo to pin A3
  rightArm.attach(A2); // Attach right arm servo to pin A2
 
  // Set initial positions for the arms
  leftArm.write(0, 0, true); // Neutral position with arms facing down
  rightArm.write(180, 0, true); // Neutral position with arms facing down
 
  } // end of setup
 
 
  void loop() {
    // Update the roboEyes display
    roboEyes.update();
 
    // Check for serial input
    if (Serial.available() > 0) {
      String input = Serial.readStringUntil('\n'); // Read the serial input until a newline character
      input.trim(); // Remove any leading/trailing whitespace
 
       if (input.equalsIgnoreCase("wakeword")) {
        roboEyes.open(); //Open eyes 
        roboEyes.setAutoblinker(ON, 7, 3);
        roboEyes.setIdleMode(ON, 4, 2);
        roboEyes.setMood(DEFAULT);
       // roboEyes.anim_thinking(); //Play thinking animation  
      }
      else if (input.equalsIgnoreCase("stopthink")) {
        roboEyes.setPosition(DEFAULT);
        roboEyes.anim_laugh(); 
        roboEyes.setAutoblinker(ON, 7, 3);
        roboEyes.setIdleMode(ON, 4, 2);
        roboEyes.setMood(DEFAULT);
        Serial.println("Mood set to HAPPY");
      } 
      else if (input.equalsIgnoreCase("sad")) {
        roboEyes.setPosition(DEFAULT); 
        roboEyes.setAutoblinker(ON, 7, 3);
        roboEyes.setIdleMode(ON, 4, 2);
        // Set the eyes to SAD emotion
        roboEyes.setMood(TIRED); //TIRED = SAD
        sadActivate = true;
        Serial.println("Mood set to SAD");
      } 
      else if (input.equalsIgnoreCase("angry")) {
        roboEyes.setPosition(DEFAULT);
        roboEyes.setAutoblinker(ON, 7, 3);
        roboEyes.setIdleMode(ON, 4, 2);
        // Set the eyes to ANGRY emotion
        roboEyes.setMood(ANGRY);
        angryActivate = true;
        Serial.println("Mood set to ANGRY");
      } 
      else if (input.equalsIgnoreCase("happy")) {
        roboEyes.setPosition(DEFAULT);
        roboEyes.setAutoblinker(ON, 7, 3);
        roboEyes.setIdleMode(ON, 4, 2);
        // Set the eyes to HAPPY emotion
        roboEyes.setMood(HAPPY);
        happyActivate = true;
        Serial.println("Mood set to HAPPY");
      } 
      else if (input.equalsIgnoreCase("idle")) {
        roboEyes.setAutoblinker(ON, 7, 3);
        roboEyes.setIdleMode(ON, 4, 3);
        roboEyes.setMood(DEFAULT);
        roboEyes.anim_laugh(); // Reset thinking animation
        idleModeActive = true;     // Mark idle mode as active
        Serial.println("Mood set to idle");
      }
      else if (input.equalsIgnoreCase("confused")) {
        roboEyes.setPosition(DEFAULT);
        roboEyes.setAutoblinker(ON, 7, 3);
        roboEyes.setIdleMode(ON, 4, 2);
        roboEyes.setMood(TIRED); //Set the eyes to SAD emotion
        // Play confused animation
        roboEyes.anim_confused();
        confusedActivate = true;
        Serial.println("Playing confused animation");
      } 
      else if (input.equalsIgnoreCase("laugh")) {
        roboEyes.setPosition(DEFAULT);
        roboEyes.setAutoblinker(ON, 7, 3);
        roboEyes.setIdleMode(ON, 4, 2);
        roboEyes.setMood(HAPPY); //Set the eyes to HAPPY emotion
        // Play laugh animation
        roboEyes.anim_laugh();
        laughActivate = true;
        Serial.println("Playing laugh animation");
      }
      else if (input.equalsIgnoreCase("wave")) {
        roboEyes.setPosition(DEFAULT);
        roboEyes.setAutoblinker(ON, 7, 3);
        roboEyes.setIdleMode(ON, 4, 2);
        roboEyes.setMood(HAPPY); //Set the eyes to HAPPY emotion
        // Perform wave animation
        waveActivate = true;
        Serial.println("Performing wave animation");
      } 
      else if (input.equalsIgnoreCase("point")) {
        roboEyes.setPosition(DEFAULT);
        roboEyes.setAutoblinker(ON, 7, 3);
        roboEyes.setIdleMode(ON, 4, 2);
        roboEyes.setMood(HAPPY); //Set the eyes to HAPPY emotion
        // Perform point animation
        pointActivate = true;
        Serial.println("Performing point animation");
      } 
      else if (input.equalsIgnoreCase("nod")) {
        roboEyes.setPosition(DEFAULT);
        roboEyes.setAutoblinker(ON, 7, 3);
        roboEyes.setIdleMode(ON, 4, 2);
        roboEyes.setMood(HAPPY); //Set the eyes to HAPPY emotion
        // Perform nod animation
        nodActivate = true;
        Serial.println("Performing nod animation");
      } 
      else if (input.equalsIgnoreCase("shrug")) {
        roboEyes.setPosition(DEFAULT);
        roboEyes.setAutoblinker(ON, 7, 3);
        roboEyes.setIdleMode(ON, 4, 2);
        roboEyes.setMood(TIRED); //Set the eyes to TIRED emotion
        roboEyes.anim_confused(); //Play confused animation
        // Perform shrug animation
        nodActivate = true;
        Serial.println("Performing shrug animation");
      } 
      else {
        Serial.println("Unrecognized command");
      }
    }
 
  if (happyActivate == true) {
    interval = 200;
    if (happyCycle < 6) {
        int currentMillis = millis();
 
        if (currentMillis - previousMillis >= interval) { 
            previousMillis = currentMillis; 
 
            if (armMovingUp) {
                // Raise arms
                leftArm.write(180, 150);  
                rightArm.write(40, 150);  
                armMovingUp = false;  
            } else {
                // Lower arms slightly
                leftArm.write(140, 150);   
                rightArm.write(0, 150);   
                armMovingUp = true;   
                happyCycle += 1;      
            }
        }
    } else {
        happyCycle = 0;
        happyActivate = false;
        leftArm.write(0, 120);
        rightArm.write(180, 120); // Reset Arms
      }
    }
 
  if (sadActivate == true) {
    interval = 600;
    if (sadCycle < 3) {
        int currentMillis = millis();
 
        if (currentMillis - previousMillis >= interval) {
            previousMillis = currentMillis;
 
            if (armMovingUp) {
                // Move arms up
                leftArm.write(45, 35);  
                rightArm.write(135, 35);  
                armMovingUp = false;
            } else {
                // Move arms down
                leftArm.write(0, 35);   
                rightArm.write(180, 35);   
                armMovingUp = true; 
                sadCycle += 1; 
            }
        }
    } else {
        sadCycle = 0;  
        sadActivate = false;    
        leftArm.write(0, 35);
        rightArm.write(180, 35); // Reset Arms
      }
   }
 
  if (angryActivate == true) {
    interval = 200;
    if (angryCycle < 5) {
        int currentMillis = millis();
 
        if (currentMillis - previousMillis >= interval) {
            previousMillis = currentMillis;
 
            if (armMovingUp) {
                // Move arms up
                leftArm.write(110, 0);  
                rightArm.write(150, 0);  
                armMovingUp = false;
            } else {
                // Move arms down
                leftArm.write(30, 0);   
                rightArm.write(70, 0);   
                armMovingUp = true; 
                angryCycle += 1; 
            }
        }
    } else {
        angryCycle = 0;         
        angryActivate = false; 
        leftArm.write(0, 0);
        rightArm.write(180, 0); // Reset Arms
    }
   }
 
  if (confusedActivate == true) {
    interval = 215;
    if (confusedCycle < 4) {
        int currentMillis = millis();
 
        if (currentMillis - previousMillis >= interval) {
            previousMillis = currentMillis;
 
            if (armMovingUp) {
              // Move arms up
                leftArm.write(40, 100);  
                rightArm.write(115, 100);  
                armMovingUp = false; 
            } else {
              // Move arms down
                leftArm.write(65, 100);   
                rightArm.write(140, 100);   
                armMovingUp = true;
                confusedCycle += 1;
            }
        }
    } else {
        confusedCycle = 0;       
        confusedActivate = false;
        leftArm.write(0, 100);
        rightArm.write(180, 100); // Reset Arms
      }
   }
 
  if (laughActivate == true) {
    interval = 200;
    if (laughCycle < 5) {
        int currentMillis = millis();
 
        if (currentMillis - previousMillis >= interval) {
            previousMillis = currentMillis; 
 
            if (armMovingUp) {
              // Move arms up
                leftArm.write(130, 150);  
                rightArm.write(50, 150);  
                armMovingUp = false; 
            } else {
                // Move arms down
                leftArm.write(30, 150);   
                rightArm.write(150, 150);   
                armMovingUp = true;  
                laughCycle += 1;
            }
        }
    } else {
        laughCycle = 0;       
        laughActivate = false;
        leftArm.write(0, 150);
        rightArm.write(180, 150); // Reset Arms
    }
   }
 
  if (waveActivate == true) {
    interval = 225;
    if (waveCycle < 4) {
        int currentMillis = millis();
 
        if (currentMillis - previousMillis >= interval) {
            previousMillis = currentMillis;
 
            if (armMovingUp) {
                // Move arms up
                leftArm.write(90, 150);  
                rightArm.write(180, 150);  
                armMovingUp = false;
            } else {
                // Move arms down
                leftArm.write(150, 150);   
                rightArm.write(180, 150);   
                armMovingUp = true;   
                waveCycle += 1;   
            }
        }
    } else {
        waveCycle = 0;
        waveActivate = false;
        leftArm.write(0, 150);
        rightArm.write(180, 150); // Reset Arms
    }
   }
 
  if (nodActivate == true) {
    interval = 150;
    if (nodCycle < 2) {
        int currentMillis = millis();
 
        if (currentMillis - previousMillis >= interval) {
            previousMillis = currentMillis;
 
            if (armMovingUp) {
              //Move arms up
                leftArm.write(120, 100);  
                rightArm.write(60, 100);  
                armMovingUp = false;
            } else {
              //Move arms down
                leftArm.write(85, 100);   
                rightArm.write(95, 100);   
                armMovingUp = true;
                nodCycle += 1;
            }
        }
    } else {
        nodCycle = 0; 
        nodActivate = false;
        leftArm.write(0, 100);
        rightArm.write(180, 100); // Reset arms
    }
   }
 
  if (pointActivate == true) {
    interval = 2000;
    if (pointCycle < 1) {
        int currentMillis = millis();
 
        if (currentMillis - previousMillis >= interval) {
            previousMillis = currentMillis;
 
            if (armMovingUp) {
              // Move arms up
                leftArm.write(0, 130);  
                rightArm.write(30, 130);  
                armMovingUp = false;
            } else {
                // Move arms down
                leftArm.write(0, 130);   
                rightArm.write(30, 130);   
                armMovingUp = true;
                pointCycle += 1;
            }
        }
    } else {
        pointCycle = 0; 
        pointActivate = false;
        leftArm.write(0, 130);
        rightArm.write(180, 130); //Reset arms
    }
   }
 
 
  if (idleModeActive) {
    startTime = millis(); // record the start time
    idleModeActive = false; // set the flag to false
    idleCount = true;
   }
 
 
  if (idleCount && millis() - startTime >= 10*60000) {
    roboEyes.close();
    roboEyes.setPosition(DEFAULT);
    roboEyes.setAutoblinker(OFF);
    roboEyes.setIdleMode(OFF);
    Serial.println("Idle mode deactivated after 10 minutes.");
    idleModeActive = false; 
    idleCount = false;
   }
}

/* 
Arduino Mega + A4988
Capteurs (IR en U) + potentiomètre contrôle distance et direction après recul
 
--- Diagramme d’état : Moteur + Potar + Capteurs ---
 
[START / Moteur immobile]
         |
         | Potar bougé → au-delà zone morte
         v
[Déplacement par potar]
         |
         | Capteur déclenché (IR)
         v
[Recul 1 cm en micro-pas]
         |
         | Recul terminé
         v
[Moteur en PAUSE après recul]
         |
         | Potar manipulé par l'utilisateur (delta > zone morte)
         v
[Reprise contrôle par potar]
         |
         +--> [Déplacement par potar]
 
*/
 
// Moteur PIN
const int MOTOR_DIR_PIN = 2;
const int MOTOR_STEP_PIN = 3;
const int MOTOR_ENABLE_PIN = 6;
 
// EndStop PIN signal
const int ENDSTOP_IR0 = 7;
const int ENDSTOP_IR1 = 11;
 
// EndStop MSx PIN
const int MS1_PIN = 8;
const int MS2_PIN = 9;
const int MS3_PIN = 10;
 
// Potentiomètre PIN Signal
const int POT_PIN = A0;
 
// Paramètres moteur
const int Nb_Recul = 200;        // 1cm en full-step=400pas --- 0.5cm en full-step=200pas
const int microStepFactor = 16;   // micro-pas pour recul
 
/* 
Le moteur avance d’un pas à chaque impulsion STEP.
La vitesse du moteur dépend uniquement du temps entre deux impulsions.
motorDelayMax est grand, plus le mouvement minimal est lent et précis.
Plus motorDelayMin est petit, plus le moteur va vite.
*/
const int motorDelayMax = 1500;   // microsecondes max STEP µs (lent)  1500 ≈ 1 mm/s
const int motorDelayMin = 400;    // microsecondes min STEP µs (rapide) 400 ≈ 3,9 mm/s
 
/* 
La zone morte (deadZone) est un intervalle central autour de la valeur neutre du potar où aucun mouvement du moteur n’est déclenché.
Exemple : const int deadZone = 50;
Si le potentiomètre est entre -50 et +50 autour du centre, le moteur reste immobile.
*/
const int deadZone = 200;          // zone morte du potar
 
const int accelStep = 1;          // incrément de lissage pour acceleration 2  4
 
bool reculEffectue = false;       // vrai après recul
bool pauseAfterRecul = false;     // moteur en pause après recul
int potRef = 0;                   // valeur de référence du potar après recul
int ir0LastState = 0;
int ir1LastState = 0;
 
 
int currentDelay = motorDelayMax;
bool potInverted = false;         // true = inverser la direction du potar
 
// Fonction STEP simple
void stepMotor(int delayMicro) {
  digitalWrite(MOTOR_STEP_PIN, HIGH);
  delayMicroseconds(delayMicro);
  digitalWrite(MOTOR_STEP_PIN, LOW);
  delayMicroseconds(delayMicro);
}
 
void setup() {
  pinMode(MOTOR_DIR_PIN, OUTPUT);
  pinMode(MOTOR_STEP_PIN, OUTPUT);
  pinMode(MOTOR_ENABLE_PIN, OUTPUT);
 
  // pinMode(ENDSTOP_MECA, INPUT_PULLUP);
  pinMode(ENDSTOP_IR0, INPUT);
  pinMode(ENDSTOP_IR1, INPUT);
 
  pinMode(MS1_PIN, OUTPUT);
  pinMode(MS2_PIN, OUTPUT);
  pinMode(MS3_PIN, OUTPUT);
 
  // Micro-pas 1/16 pour recul
  digitalWrite(MS1_PIN, HIGH);
  digitalWrite(MS2_PIN, HIGH);
  digitalWrite(MS3_PIN, HIGH);
  digitalWrite(MOTOR_ENABLE_PIN, LOW);
 
  delay(100); // stabilisation capteurs
  ir0LastState = digitalRead(ENDSTOP_IR0);
  ir1LastState = digitalRead(ENDSTOP_IR1);
}
 
void loop() {
  // ===== Lecture potar =====
  int potValue = analogRead(POT_PIN) - 512;
  int potAbs = abs(potValue);
 
  // Détermination direction potar avec inversion si activé
  bool direction = potInverted ? (potValue < 0) : (potValue > 0);
 
  // ===== Lecture capteurs =====
  int ir0State = digitalRead(ENDSTOP_IR0);
  int ir1State = digitalRead(ENDSTOP_IR1);
 
  bool ir0Triggered  = (ir0State == HIGH && ir0LastState == LOW);
  bool ir1Triggered  = (ir1State == HIGH && ir1LastState == LOW);
 
  // ===== Recul 1 cm si capteur déclenché =====
  if(!reculEffectue && (ir0Triggered || ir1Triggered)){
    delay(50);
 
    // Micro-pas pour recul
    digitalWrite(MS1_PIN, HIGH);
    digitalWrite(MS2_PIN, HIGH);
    digitalWrite(MS3_PIN, HIGH);
    digitalWrite(MOTOR_DIR_PIN, !direction); // reculer dans sens opposé au potar
    for(int i=0; i<Nb_Recul*microStepFactor; i++){
      stepMotor(motorDelayMin);
    }
 
    // Recul terminé → moteur en pause
    reculEffectue = true;
    pauseAfterRecul = true;
    potRef = potValue; // mémoriser la valeur du potar après recul
 
    // Mise à jour états capteurs
    ir0LastState = digitalRead(ENDSTOP_IR0);
    ir1LastState = digitalRead(ENDSTOP_IR1);
 
    return; // ne rien faire d'autre
  }
 
  // ===== Vérification pause après recul =====
  if(pauseAfterRecul){
    int deltaPot = abs(potValue - potRef);
    if(deltaPot > deadZone){
      // l'utilisateur a bougé le potar → reprise
      pauseAfterRecul = false;
    } else {
      return; // moteur reste en pause
    }
  }
 
  // ===== STEP proportionnel au potar avec acceleration =====
  if(potAbs >= deadZone){
    // Micro-pas 1/16 pour recul
    digitalWrite(MS1_PIN, HIGH);
    digitalWrite(MS2_PIN, HIGH);
    digitalWrite(MS3_PIN, HIGH);
    /* 
    // Passer en full-step pour potar
    digitalWrite(MS1_PIN, LOW);
    digitalWrite(MS2_PIN, LOW);
    digitalWrite(MS3_PIN, LOW); 
    */
    digitalWrite(MOTOR_DIR_PIN, direction);
 
    // Calcul vitesse cible selon potar
    int targetDelay = map(potAbs, deadZone, 512, motorDelayMax, motorDelayMin);
    targetDelay = constrain(targetDelay, motorDelayMin, motorDelayMax);
 
    // Lissage acceleration/déceleration
    if(currentDelay < targetDelay)
      currentDelay += accelStep;
    else if(currentDelay > targetDelay)
      currentDelay -= accelStep;
 
    currentDelay = constrain(currentDelay, motorDelayMin, motorDelayMax);
 
    stepMotor(currentDelay);
 
    // Autoriser un nouveau recul si le potar est utilisé après recul
    if(reculEffectue){
      reculEffectue = false;
    }
  }
 
  // Mise à jour derniers états des capteurs
  ir0LastState = ir0State;
  ir1LastState = ir1State;
}