Cela fait un petit temps que j’aimerai mieux logger toute une série d’informations sortants de mes programmes. Je n’ai pas encore passé le cap en Python. Cela va venir, j’en suis certain.

Pour l’ESP32, j’ai malgré moi passé le cap en étudiant le code de

J’ai parcouru différents tutoriaux pour débutants pour l’Arduino (ou l’ESP32). Généralement, nous y retrouvons une explication théorique sur l’électricité (les électrons, le sens “naturel” et “conventionel”, la loi d’Ohm, … ) puis des montages simples : une LED, un bouton, …

Globalement, c’est assez similaire.

Toutefois, j’ai bien aimé celui de ESP32I/O où les exemples sont un peu plus nombreux. Il propose notament de faire clignoter une LED tout en faisant tourner le script pour d’autres fonctions (voir LED Blink without delay)

Le site reprend également l’exemple de la LED qui reste allumée tant que j’appuie Button toggle LED.

Quid si j’appuie sur le boutton et que la LED clignote jusqu’à ce que je ré-appuie sur le boutton ? Ci-dessous un petit exemple de programme qui le permettra :

#define LED_PIN     26 // ESP32 pin GPIO26 connected to LED
#define BUTTON_PIN  25 // ESP32 pin GPIO25 connected to button

#define BLINK_INTERVAL 1000  // interval at which to blink LED (milliseconds)

// Variables will change:
int ledState = LOW;   // ledState used to set the LED

int previousButtonState = LOW; // will store last time button was updated
int blinking = LOW; // store status of LED (must LED blink or not)

unsigned long previousMillis = 0;   // will store last time LED was updated

void setup() {
  Serial.begin(9600);

  // set the digital pin as output:
  pinMode(LED_PIN, OUTPUT);

  // set the digital pin as an input:
  pinMode(BUTTON_PIN, INPUT_PULLUP);
}

void loop() {
  // check to see if it's time to blink the LED; that is, if the difference
  // between the current time and last time you blinked the LED is bigger than
  // the interval at which you want to blink the LED.
  unsigned long currentMillis = millis();

  // check button state's change
  int currentButtonState = digitalRead(BUTTON_PIN);

    if (currentMillis - previousMillis >= BLINK_INTERVAL && blinking == HIGH) {
        // if the LED is off turn it on and vice-versa:
        ledState = (ledState == LOW) ? HIGH : LOW;

        // set the LED with the ledState of the variable:
        digitalWrite(LED_PIN, ledState);

        // save the last time you blinked the LED
        previousMillis = currentMillis;
    } else if (currentMillis - previousMillis >= BLINK_INTERVAL && blinking == LOW){

        // if the LED is off turn it on and vice-versa:
        ledState = LOW;

        // set the LED with the ledState of the variable:
        digitalWrite(LED_PIN, ledState);

        // save the last time you blinked the LED
        previousMillis = currentMillis;
    }

    if (currentButtonState != previousButtonState ) {
        // print out the state of the button:
        Serial.println(currentButtonState);
        // save the last state of button
        previousButtonState = currentButtonState;
        if (previousButtonState == HIGH){
            blinking = (blinking == LOW) ? HIGH : LOW;
        }
        Serial.println(blinking);
    }
    // DO OTHER WORKS HERE
}

Premier projet : faire tourner un e-paper. Pourquoi ? Parce que cela a l’air. C’est assez bête; je l’avoue.

Ni une, ni deux, j’achète le modèle suivant : Pico e-Paper 2.66B. Il arrive assez vite. Toutefois, je le laisse de côté car d’autres activités m’occupent.

Le temps passe et quelques semaines mois après, je m’y intéresse enfin. Quel malheur ! C’est une version Pico (et non une version simple). Pas de chance car je n’ai pas de Pico. Est-ce qu’il fonctionne ? Après moultes hésitations, je décide de le connecter en suivant le tableau de connexion repris sur le wiki.

Ouf ! il fonctionne bien. Pour que ce soit plus pratique, je prends un Pico (heureusement pas trop cher) chez mon dealer du coin McHobby.

Le e-Paper possède bien une librairie Python. Sauf que … c’est assez limité car elle fait recours à FrameBuffer. Donc impossibilité de jouer sur la fonte.

Peter Hinch a développé la librairie MicroPython font_to_py. Cela permet de convertir une fonte à une taille fixée sur le Pico en transformant un ensemble de caractères en code source Python. Coen Tempelaars a réutilisé cela pour écrire de manière centrée via la class CenterWriter.

Avec cela, je peux écrire dans une taille plus grande que celle permise par FrameBuffer. Sauf que j’aimerai également changer le sens d’écriture. La connectique du e-Paper fait que le cable d’alimentation USB sort par le haut. J’aurai aimé qu’il sorte sur le côte (rotation à 90° ou 270°). Et si ce n’est pas possible, qu’il sorte vers le bas. C’est possible (en s’inspirant du code fourni pour d’autres e-Paper de la même marque et du repo).

Je dois encore explorer certains repos.

La problématique suivante est l’utilisation de la couleur. Pour ce que j’ai vu, soit c’est noir&blanc soit multicouleurs. Pas de tricolor.

Bref, il y a encore de l’exploration à faire.