Générateur de fonctions avec l'ESP32, écran et boîtier - [Partie 3]

Après avoir ajouté un amplificateur dans la deuxième partie avec lequel vous pouvez régler l'amplitude ainsi que le décalage, nous voulons maintenant faire l'opération directement sur l'appareil au lieu d'utiliser le moniteur série.

Par exemple, le LCD1602 Display Keypad Shield convient, qui dispose d'un écran LCD de deux lignes de 16 caractères et de boutons pour le fonctionnement. Ce bouclier a été conçu pour l'Arduino. Pour faciliter l'utilisation de l'ESP32, nous remplaçons le DevKit CV4 ESP32 de la première partie par la carte ESP32 D1 R32, dont les broches de connexion sont disposées comme celles d'un Arduino Uno. On peut donc brancher le bouclier directement sur elle. Cependant, les exemples ne fonctionneront pas car l'ESP32 a des broches d'entrée/sortie différentes de celles de l'Arduino. En outre, il convient de noter que les entrées de la ESP32 ne tolèrent que 3,3 V.

Les figures montrent le brochage de la carte ESP32 D1 R32 et le brochage du blindage du clavier LCD. Seules les épingles qui sont réellement utilisées sont marquées.

Comme toutes les broches de l'écran LCD sont utilisées comme entrées du contrôleur LCD, nous n'avons pas à nous inquiéter de la tension, car les entrées fonctionneront en toute sécurité même avec 3,3V.

La situation est quelque peu différente avec la connexion par bouton-poussoir. Selon le bouton pressé, il délivre une valeur comprise entre 0 et 5V. Sur le Shield, la sortie est connectée à la borne +5V via une résistance de 2 kOhm. Si nous soudons maintenant une résistance de 3,9 kOhm entre le connecteur du bouton et le connecteur 0V, la tension maximale à ce connecteur est seulement de 5V * 3900 / (2000 + 3900) = 3,3V. Sur la photo, vous pouvez voir cette résistance.  

Nous avons un autre problème avec le connecteur GPIO12. Il doit être réglé sur 0V pendant le processus de démarrage, sinon la tension de fonctionnement de la mémoire flash est commutée sur 1,8V. Ici aussi, une résistance de 10 kOhm entre GPIO12 et GND aide. Mais nous ferions mieux de souder cette résistance à la carte ESP32 D1 R32, car ce problème peut également se produire avec d'autres boucliers Arduino.

Figure 1 : Brochage de l'ESP32 D1 R32

Figure 2 : Brochage du blindage du clavier LCD (uniquement les connecteurs utilisés)

Figure 3 : Panneau arrière ESP32 D1 R32 avec résistance de 10 kOhm entre GPIO12 et GND

Matériel nécessaire

Voici à nouveau toutes les parties, y compris celles de la deuxième partie.

Le logiciel

/* 
 *  Funktionsgenerator für Sinus, Dreieck und Rechteck Signale
 *  Einstellbare Frequenz 20 Hz bis 20 KHz
 *  Für Dreieck und Rechteck einstellbares Tastverhältnis 0 bis 100%
*/

//Bibliotheken zum direkten Zugriff auf Steuerregister des ESP32
#include "soc/rtc_cntl_reg.h"
#include "soc/sens_reg.h"
#include "soc/rtc.h"

//Bibliotheken zur Verwendung des Digital zu Analog Konverters und für den I2S-Bus
#include "driver/dac.h"
#include "driver/i2s.h"

//Bibliothek für das LCD Display
#include <LiquidCrystal.h>

#define SINFAKT 127.0 //gemessen für Schrittweite = 1 und kein Vorteiler (8.3MHz)
#define SIGNALOUT 26 //Pin für die Signalausgabe


//LCD Pins
#define PIN_RS 12  //Registerselect 0=Befehle 1=Daten
#define PIN_EN 13  //Enable Takt zum Schreiben
#define PIN_D4 17  //Datenbit 
#define PIN_D5 16  //Datenbit
#define PIN_D6 27  //Datenbit
#define PIN_D7 14  //Datenbit
#define PIN_BL 5   //Hintergrundbeleuchtung 0=aus

//Analog PIN für Tasten
#define KEYS A12

//Spannungsteiler für Tasten
#define Rv 2000  //Vorwiderstand
#define R3 3900  //Schutzwiderstand für maximal 3.3 V
#define Rp 1000  //Widerstand GPIO2 gegen Masse
#define Rr 0     //Spannungsteiler bei gedrückter RIGHT Taste
#define Ru 330   //Spannungsteiler bei gedrückter UP Taste
#define Rd 950   //Spannungsteiler bei gedrückter DOWN Taste
#define Rl 1950  //Spannungsteiler bei gedrückter LEFT Taste
#define Rs 5250  //Spannungsteiler bei gedrückter SELECT Taste

//Tasten Codes
#define NONE    0
#define LEFT    1
#define RIGHT   2
#define UP      3
#define DOWN    4
#define SELECT  5

//Betriebsarten
#define MSINUS 0
#define MRECTANGLE 1
#define MTRIANGLE 2

//Änderungstypen
#define EMODE 0
#define EFREQUENCY 1
#define ERATIO 2

// Init I2C LCD
LiquidCrystal lcd(PIN_RS, PIN_EN, PIN_D4, PIN_D5, PIN_D6, PIN_D7);

//Variablen zum Speichern der Schwellwerte für Taster
uint16_t Ur, Uu, Ud, Ul, Us;

//Buffer zum Erstellen der Dreieckfunktion
uint32_t buf[128];

//Einstellwerte für Kurvenform, Frequenz und Tastverhältnis
int8_t mode = MSINUS; //0=Sinus, 1=Rechteck, 2=Dreieck
float frequency = 1000; //20 bis 200000 Hz
int8_t ratio = 50; //Tastverhältnis 0 bis 100%

int8_t edit = EMODE; //was wird verändert 0=Mode 1=Frequenz 2=Tastverhältnis

uint32_t tic; //Für Wartezeit

int8_t lastKey = 0; //zuletzt ermittelte Taste oder 0 wenn keine
uint16_t step = 0;  //Schrittweite für Frequenzerhöhung
float ftmp;         //Variable zum Speichern der Frequenz während der Einstellung
int16_t rtmp;       //Variable zum Speichern des Tastverhältnis während der Einstellung
int8_t mtmp;        //Variable zum Speichern der Betriebsart während der Einstellung

//Flag Ist wahr, wenn die Initialisierung bereits erfolgte
bool initDone = false;


//Konfiguration für den I2S Bus
i2s_config_t i2s_config = {
     .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX | I2S_MODE_DAC_BUILT_IN), //Betriebsart
     .sample_rate = 100000, //Abtastrate
     .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT, // der DAC verwendet nur 8 Bit des MSB
     .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT, // Kanalformat ESP32 unterstützt nur Stereo
     .communication_format = (i2s_comm_format_t)I2S_COMM_FORMAT_I2S_MSB, //Standard Format für I2S
     .intr_alloc_flags = 0, // Standard Interrupt 
     .dma_buf_count = 2, //Anzahl der FIFO Buffer
     .dma_buf_len = 32, //Größe der FIFO Buffer
     .use_apll = 0 //Taktquelle
    };


//Buffer für Dreieck Wellenform füllen
//Parameter up ist die Dauer für den Anstieg in Prozent
//Parameter sz gibt die Buffergröße für eine Periode an
//es werden die Werte für eine Periode in den Buffer geschrieben
void fillBuffer(uint8_t up, uint8_t sz) {
  uint8_t down;  //Zeit für die fallende Flanke in %
  uint32_t sample; //32Bit Datenwort (I2S benötigt zwei Kanäle mit je 16 Bit
  float du,dd,val; //Hilfsvariablen
  down=100-up;
  //Anzahl der Schritte für Anstieg und Abfall berechnen
  uint16_t stup = round(1.0*sz/100 * up);
  uint16_t stdwn = round(1.0*sz/100*down);
  uint16_t i;
  if ((stup + stdwn) < sz) stup++;//Ausgleich eventueller Rundungsfehler
  //Amplitudenänderung pro Schritt für Anstieg und Abfall 
  du = 256.0/stup;
  dd = 256.0/stdwn;
  //füllen des Buffers
  val = 0; //Anstieg beginnt mit 0
  for (i=0; i<stup; i++) {
    sample = val; 
    sample = sample << 8; //Byte in das höherwertige Byte verschieben 
    buf[i]=sample;
    val = val+du; //Wert erhöhen
  }
  val=255; //Abfallende Flanke beginnt mit Maximalwert
  //Rest wie bei der ansteigenden Flanke
  for (i=0; i<stdwn; i++) {
    sample = val;
    sample = sample << 8;
    buf[i+stup]=sample;
    val = val-dd;
  }
}


//Alle  Ausgänge stoppen
void stopAll(){
    ledcDetachPin(SIGNALOUT); 
    i2s_driver_uninstall((i2s_port_t)0); 
    dac_output_disable(DAC_CHANNEL_2);
    dac_i2s_disable();
    initDone=false;
}

//Kurvenform Rechteck starten
//Pin für Signalausgang zuweisen
void startRectangle(){
    ledcAttachPin(SIGNALOUT,1 );
    initDone=true;
}

//Frequenz für Rechteck setzen mit entsprechendem Tastverhältnis
void rectangleSetFrequency(double frequency,uint8_t ratio)
{
    ledcSetup(1,frequency,7); //Wir nutzen die LEDC Funktion mit 7 bit Auflösung
    ledcWrite(1,127.0*ratio/100);  //Berechnung der Schrittanzahl für Zustand = 1
}


//Dreiecksignal starten
void startTriangle(){
  i2s_set_pin((i2s_port_t)0, NULL); //I2S wird mit dem DAC genutzt
    initDone=true;
}

//Frequenz für Dreieck setzen mit entsprechendem Tastverhältnis
double triangleSetFrequency(double frequency,uint8_t ratio)
{
  int size=64;
  //zuerst wird die geeignete Buffergröße ermittelt
  //damit die Ausgabe funktionier muss die I2S Abtastrate zwischen
  //5200 und 650000 liegen
  if (frequency<5000) {
    size = 64;
  } else if (frequency<10000) {
    size = 32;
  } else if (frequency<20000) {
    size = 16;
  } else {
    size = 8;
  }
  //Abtastrate muss in einer Periode beide Buffer ausgeben
  uint32_t rate = frequency * 2 * size;
  //Die Abtastrate darf nur innerhalb der Grenzwerte liegen
  if (rate < 5200) rate = 5200;
  if (rate > 650000) rate = 650000;
  //wirklichen Frequenzwert setzen
  frequency = rate / 2 / size;

  //I2S Treiber entfernen 
  i2s_driver_uninstall((i2s_port_t)0);
  //Konfiguration anpassen 
  i2s_config.sample_rate = rate;
  i2s_config.dma_buf_len = size;
  //und mit der neuen Konfiguration installieren
  i2s_driver_install((i2s_port_t)0, &i2s_config, 0, NULL);
  //Abtastrate einstellen
  i2s_set_sample_rates((i2s_port_t)0, rate); 
  //Buffer füllen
  fillBuffer(ratio,size*2);
  //und einmal ausgeben
  i2s_write_bytes((i2s_port_t)0, (const char *)&buf, size*8, 100);  
  return frequency;
}

//Sinusausgabe vorbereiten
void startSinus(){
    //Ausgang für Signalausgang freigeben
    dac_output_enable(DAC_CHANNEL_2);
    // Sinusgenerator aktivieren
    SET_PERI_REG_MASK(SENS_SAR_DAC_CTRL1_REG, SENS_SW_TONE_EN);
    // Ausgabe auf Kanal 1 starten
    SET_PERI_REG_MASK(SENS_SAR_DAC_CTRL2_REG, SENS_DAC_CW_EN2_M);
    // Vorzeichenbit umkehren
    SET_PERI_REG_BITS(SENS_SAR_DAC_CTRL2_REG, SENS_DAC_INV2, 2, SENS_DAC_INV2_S);
    initDone=true;
}

//Frequenz für Sinus setzen
double sinusSetFrequency(double frequency)
{
  //Formel f = s * SINFAKT / v
  //s sind die Schritte pro Taktimpuls
  //v ist der Vorteiler für den 8MHz Takt
  //Es gibt 8 Vorteiler von 1 bis 1/8 um die Kombination Vorteiler und
  //Schrittanzahl zu finden, testen wir alle acht Vorteiler Varianten
  //Die Kombination mit der geringsten Frequenzabweichung wird gewählt
  
    double f,delta,delta_min = 999999999.0;
    uint16_t divi=0, step=1, s;
    uint8_t clk_8m_div = 0;//0 bis 7
    for (uint8_t div = 1; div<9; div++){
      s=round(frequency * div/SINFAKT);
      if ((s>0) && ((div == 1) || (s<1024))) {
        f= SINFAKT*s/div;
        /*
        Serial.print(f); Serial.print(" ");
        Serial.print(div); Serial.print(" ");
        Serial.println(s);
        */
        delta = abs(f-frequency);
        if (delta < delta_min) { //Abweichung geringer -> aktuelle Werte merken
          step = s; divi = div-1; delta_min = delta;
        }
      }
    }
    //wirklichen Frequenzwert setzen
    frequency = SINFAKT * step / (divi+1);
    // Vorteiler einstellen
    REG_SET_FIELD(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_CK8M_DIV_SEL, divi);
    // Schritte pro Taktimpuls einstellen
    SET_PERI_REG_BITS(SENS_SAR_DAC_CTRL1_REG, SENS_SW_FSTEP, step, SENS_SW_FSTEP_S);
    return frequency;
}

//Einstellungsänderungen durchführen
void controlGenerator() {
  switch (mode) {
    case MSINUS: if (!initDone) startSinus();
        frequency = sinusSetFrequency(frequency);
        break;
    case MRECTANGLE : if (!initDone) startRectangle();
        rectangleSetFrequency(frequency,ratio);
        break;
    case MTRIANGLE : if (!initDone) startTriangle();
        frequency = triangleSetFrequency(frequency,ratio);
        break;
  }
}

//Anzeige aktualisieren
//Wenn monitor wahr ist, erfolgt die Ausgabe 
//auch auf die serielle Schnittstelle
void displayValues(boolean monitor) {
  char buf[15];
  //aktuelle Werte ausgeben
  String ba;
  switch (mode) {
    case MSINUS: ba="Sinus     "; break;
    case MRECTANGLE: ba="Rechteck  "; break;
    case MTRIANGLE: ba="Dreieck   "; break;
  }
  //Betriebsart ausgeben
  lcd.setCursor(0,0);
  lcd.print(" ");
  lcd.print(ba);
  if (monitor) {
    Serial.println("**************** Eingestellte Werte *************************");
    Serial.print("Betriebsart    = "); Serial.println(ba);
  }
  //Frequenz je nach Wert als Hz oder kHz
  if (frequency < 1000){
    sprintf(buf,"%6.2f Hz",frequency);
  } else {
    sprintf(buf,"%6.2fkHz",frequency/1000);
  }
  //Frequenz ausgeben
  lcd.setCursor(0,1);
  lcd.print(" F"); lcd.print(buf);
  if (monitor) {
    Serial.print("Frequenz       = "); Serial.println(buf);
  }
  sprintf(buf,"%2i%%",ratio);
  //Tastverhältnis ausgeben
  lcd.setCursor(11,1);
  lcd.print(" T"); lcd.print(buf);
  if (monitor) {
    Serial.print("Tastverhältnis = "); Serial.println(buf);
    Serial.println();
  }
  //je nach Edit-Mode Pfeilzeichen ausgeben
  switch (edit) {
    case EMODE: lcd.setCursor(0,0); break;
    case EFREQUENCY: lcd.setCursor(0,1); break;
    case ERATIO: lcd.setCursor(11,1); break;
  }
  lcd.print(char(126));
}

//Edit Mode ändern mit UP und DOWN Taste
void changeEdit(boolean up) {
  //je nach Richtung Schritte positiv oder negativ
  int s = up?1:-1;
  edit += s;
  //am Ende wieder auf Anfang springen
  if (edit < 0) edit = 2;
  if (edit > 2) edit = 0;
  //die aktuellen Werte in die temporären Werte
  //für die Änderung kopieren
  ftmp = frequency;
  rtmp = ratio;
  mtmp = mode;
  //Geänderte Editmode ausgeben
  Serial.print("Mode = ");Serial.println(mode);
  //Anzeige aktualisieren ohne Ausgabe auf serielle
  //Schnittstelle
  displayValues(false);
}

//Betriebsart ändern mit RIGHT und LEFT Taste
void changeMode(boolean up) {
  //je nach Richtung Schritte positiv oder negativ
  int s = up?1:-1;
  //temporäre Betriebsart ändern
  mtmp += s;
  //Wenn das Ende erreicht wird wieder auf Anfang springen
  if (mtmp < 0) mtmp = 2;
  if (mtmp > 2) mtmp = 0;
  //Geänderte Betriebsart am Display anzeigen
  lcd.setCursor(1,0);
  switch (mtmp) {
    case 0: lcd.print("Sinus     "); break;
    case 1: lcd.print("Rechteck  "); break;
    case 2: lcd.print("Dreieck   "); break;
  }
}

//Frequenz ändern mit RIGHT und LEFT Taste
void changeFrequency(boolean up) {
  //war die Taste vorher nicht gedrückt, wird die Schrittweite auf 1 gesetzt
  //während die Taste gedrückt bleibt, wird die Schrittweite laufend
  //verdoppelt bis eine maximale Schrittweite erreicht wurde
  step = (lastKey == NONE)?1:step*2;
  if (step > 1024) step = 1024;
  //Richtungsfaktor bestimmen
  int16_t s = up?1:-1;
  //temporäre Frequenz ändern
  ftmp = ftmp+s*step;
  //auf Minimal- und Maximalwerte prüfen
  if (ftmp < 20) ftmp=20;
  if (ftmp > 20000) ftmp = 20000;
  char buf[15];
  //Für die Anzeige Hz oder kHz
  if (ftmp > 999) {
    sprintf(buf,"%6.2fkHz",ftmp/1000.0);
  } else {
    sprintf(buf,"%6.2f Hz",ftmp*1.0);
  }
  //Geänderte Frequenz am Display anzeigen
  lcd.setCursor(2,1);
  lcd.print(buf);
}

//Tastverhältnis ändern mit RIGHT und LEFT Taste
void changeRatio(boolean up) {
  //Richtung festlegen
  int8_t jx = up?1:-1;
  //Temporäres Tastverhältnis ändern
  rtmp = rtmp+jx;
  //auf Minimal- und Maximalwerte prüfen
  if (rtmp < 0) rtmp=0;
  if (rtmp > 100) rtmp = 100;
  char buf[15];
  //Geändertes Tastverhältnis am Display anzeigen
  sprintf(buf,"%2i%%",rtmp);
  lcd.setCursor(13,1);
  lcd.print(buf);  
}

//der Funktionsgenerator wird auf die geänderte Einstellung gesetzt
//die temporären Werte werden in die Aktuellen Werte übernommen
void setValues() {
  Serial.print("Set values edit = "); Serial.println(edit);
  switch (edit) {
    case EMODE: stopAll(); mode = mtmp; break;
    case EFREQUENCY: frequency = ftmp; break;
    case ERATIO: ratio = rtmp; break;
  }
  //Funktionsgenerator selber ändern
  controlGenerator();
  displayValues(true);
}

//Tastaturspannung einlesen und auswerten
void handleKeys() {
  //Tastaturspannung einlesen
  int x=analogRead(KEYS);
  uint8_t key = NONE;
  if (x < Ur) { key = RIGHT; }
  else if (x < Uu) { key = UP; }
  else if (x < Ud){ key = DOWN; }
  else if (x < Ul){ key = LEFT; }
  else if (x < Us){ key = SELECT; }
  else {key = NONE;}
  if (((key == UP) || (key == DOWN)) && (lastKey == NONE)) changeEdit(key == DOWN);
  if ((key == LEFT) || (key == RIGHT)) {
    switch (edit) {
      case EMODE: if (lastKey == NONE) changeMode(key == RIGHT); 
        break;
      case EFREQUENCY: changeFrequency(key == RIGHT); 
        break;
      case ERATIO: changeRatio(key == RIGHT); 
        break;
    }
  }
  if ((key == SELECT) && (lastKey == NONE)) setValues();
  lastKey = key; 
  tic = millis();
}
//Serielle Schnittstelle aktivieren und 
//Defaulteinstellungen 1kHz Sinus setzen
//Schwellwerte für Tastatur festlegen
void setup()
{
    Serial.begin(115200);
    controlGenerator();
    lcd.begin(16,2);                           // initialisiere LCD I2C Anzeige
    lcd.clear();
    displayValues(true);
    tic = millis();
    Serial.print("Kommando M,F,A,T,O : ");
    pinMode(2,INPUT);
    //Schwellwerte für Taster berechnen
    //Diese Berechnung ist notwendig, da die Toleranzen sehr
    //gering sind, und die Schwellwerte von der Betriebsspannung
    //abhängen.
    //Versorgungsspannung ohne Taste ermitteln
    int x=analogRead(A12);
    float Rin = R3 * Rp / (R3 + Rp);
    float Ub = x / Rin * (Rin + Rv);
    //Schwellspannungen ermitteln
    float Uup,Udn,Ulf,Usl,Rtmp;
    //Mittelwert für UP Taste
    Rtmp = Rin * Ru / (Rin + Ru);
    Uup = Ub * Rtmp / (Rtmp + Rv); 
    //Mittelwert für DOWN Taste
    Rtmp = Rin * Rd / (Rin + Rd);
    Udn = Ub * Rtmp / (Rtmp + Rv); 
    //Mittelwert für LEFT Taste
    Rtmp = Rin * Rl / (Rin + Rl);
    Ulf = Ub * Rtmp / (Rtmp + Rv); 
    //Mittelwert für Select Taste
    Rtmp = Rin * Rs / (Rin + Rs);
    Usl = Ub * Rtmp / (Rtmp + Rv); 
    //eigentliche Schwellwerte berechnen
    //immer in die Mitte zwischen zwei Mittelwerten
    Ur = Uup/2;
    Uu = Uup + (Udn - Uup) / 2;
    Ud = Udn + (Ulf - Udn) / 2;
    Ul = Ulf + (Usl - Ulf) / 2;
    Us = Usl + (x-Usl) /2;
    //Schwellwerte auf die serielle Schnittstelle ausgeben
    Serial.printf("Schwellwerte: right %i, up %i, down %i, left %i, select %i\n",Ur,Uu,Ud,Ul,Us);
    
}


void loop(){
  if ((millis()-tic) > 200) handleKeys();
  //Serielle Schnittstelle abfragen
  if (Serial.available() > 0) {
    //Befehl von der Schnittstelle einlesen
    String inp = Serial.readStringUntil('\n');
    //und zur Kontrolle ausgeben
    Serial.println(inp);
    char cmd = inp[0]; //erstes Zeichen ist das Kommando 
    if ((cmd == 'M') || (cmd == 'm')) { //war das Zeichen 'M' wird die Betriebsart eingestellt
      char newMode = inp[1]; //zweites Zeichen ist die Betriebsart
      uint8_t nm=0;
      switch (newMode) {
        case 's':
        case 'S': nm=0; break;
        case 'r':
        case 'R': nm=1; break;
        case 't':
        case 'T': nm=2; break;
      }
      if (nm != mode) { //Nur wenn eine Änderung vorliegt, muss was getan werden
        stopAll(); 
        mode=nm;
        controlGenerator();
      }
    } else {
      //bei den anderen Befehlen folgt ein Zahlenwert
      String dat = inp.substring(1);
      //je nach Befehl, werden die Daten geändert
      switch (cmd) {
        case 'F' :
        case 'f' :frequency = dat.toDouble(); break; //Frequenz
        case 'T' :
        case 't' :ratio = dat.toInt(); break;  //Tastverhältnis
      }
      //Grenzwerte werden überprüft
      if (ratio > 100) ratio = 100;
      if (frequency < 20) frequency = 20;
      if (frequency > 20000) frequency = 20000;
      controlGenerator();
    }
    //aktuelle Werte ausgeben
    displayValues(true);
    Serial.print("Kommando M,F,T : ");
  }
}

Croquis téléchargeable:

La partie relative au générateur de fonctions et à l'utilisation via l'interface série est identique au croquis de la partie 1. La nouveauté réside dans l'utilisation via les touches du clavier de l'écran d'affichage. L'évaluation des boutons, en particulier, nécessite une attention particulière.

Figure 4 : Diviseur de tension pour les touches du blindage du clavier LCD et, à gauche, la carte ESP32 D1 R32 avec la résistance parallèle

Le diviseur de tension est conçu de telle sorte qu'à 5V, la différence entre les tensions individuelles est d'environ 1V. Mais comme nous avons intégré la résistance de protection de 3900 ohms pour que la sortie n'atteigne jamais plus de 3,3V, cette différence est réduite. Mais le problème est encore plus grave. La carte ESP32 D1 R32 possède une résistance de 1 kOhm en parallèle avec l'entrée GPIO2, de sorte que seul le GPIO0 doit être connecté au GND pour le clignotement. Cette résistance réduit encore la différence de tension. Le tableau indique les tensions que vous obtenez des boutons-poussoirs (sans résistance parallèle, avec 3900 Ohm en parallèle et avec 3900 Ohm et 1000 Ohm en parallèle.

Des tests ont montré que le voltage de 5V n'est pas très précis. Avec une alimentation électrique externe, la tension était de 4,4V, l'alimentation par USB étant comprise entre 5,0V sur un port d'ordinateur et 5,2V sur un chargeur USB.

Si des valeurs seuils fixes étaient utilisées pour chaque bouton, l'appareil fonctionnerait ou non en fonction de la tension de fonctionnement. Afin de garantir un fonctionnement sûr, la tension de fonctionnement est donc déterminée lors de la mise en marche sans pression d'un bouton. Les tensions moyennes de chaque bouton peuvent alors être calculées à partir de là. Comme la requête pour l'évaluation de la clé est plus petite, le meilleur résultat est obtenu en ajoutant la moitié de la distance à la valeur moyenne supérieure suivante à la tension moyenne afin d'obtenir la valeur limite.

Le logement

Pour accroître la facilité d'utilisation, nous avons conçu un boîtier qui peut être produit avec une imprimante 3D. Le logement est construit de manière à ce que toutes les pièces puissent y entrer.

Figure 5: Boîtier de l'imprimante 3D

En bas, vous pouvez voir le renfoncement rectangulaire pour l'affichage et les ouvertures pour les boutons. A droite, à côté, se trouvent les deux trous pour les potentiomètres. Dans le mur de droite se trouve un trou pour la prise BNC et sur le mur de gauche un évidement rectangulaire pour la prise USB et pour la fiche d'alimentation.

Quatre cylindres d'écartement avec des trous sont prévus pour la fixation des circuits imprimés.

Le couvercle assorti n'a pas d'évidements et peut être simplement enfilé.

Les boutons sont disposés sur une plaque de base commune pour faciliter le montage. Pour qu'ils puissent être pressés individuellement, ils doivent être imprimés avec un filament élastique, par exemple du TPU. Si cela n'est pas possible, les différents boutons doivent être séparés de la plaque de base après l'impression afin qu'ils puissent être pressés individuellement.

Figure 6 : Boutons de l'imprimante 3D

Enfin, deux écarteurs doivent être insérés entre le bouclier et l'écran pour éviter que l'écran ne se tende lorsqu'il est vissé.

Figure 7 : Écran du clavier LCD, installation des écarteurs

 Liens pour télécharger les fichiers d'impression 3D :

Corps de fond, couvercle, Boutons, Espaceur 1, Ecarteur 2

Assemblage

Le blindage du clavier LCD comporte des points de soudure libres en plus des en-têtes utilisés pour se connecter à la carte ESP32 D1 R32, qui sont connectés en parallèle avec les en-têtes. Nous les utilisons pour connecter les modules externes à la carte. Pour cela, nous devons également les équiper de têtes d'épingle.

Figure 8 : En-têtes de broches supplémentaires sur l'écran du clavier LCD

La résistance de protection de 3,9 kOhm ne doit pas non plus être oubliée.

Nous commençons l'assemblage avec les boutons, qui sont insérés dans les évidements correspondants du boîtier.  Les deux potentiomètres avec câbles de connexion suivent. Pour les câbles de connexion, nous avons coupé en deux un fil de raccordement tripolaire et l'avons soudé aux potentiomètres. Une décharge de traction avec un serre-câble est avantageuse.

Figure 9: Installation des boutons dans le boîtier

Figure 10: Installation des potentiomètres et de la prise BNC (sortie du signal)

Un fil de raccordement bipolaire est également coupé en deux et soudé à la prise BNC.

Lorsque les deux potentiomètres et la prise BNC sont installés, le blindage du clavier LCD peut être fixé dans le boîtier à l'aide de quatre vis. N'oubliez pas d'insérer les deux entretoises entre l'affichage et le tableau. Le module transformateur de tension et le module amplificateur peuvent également être fixés à l'aide de quatre vis chacun.

Figure 11 : Boîtier avec blindage du clavier LCD, convertisseur DC-DC, amplificateur opérationnel et câblage

Les câbles peuvent maintenant être branchés selon le schéma de câblage.

Figure 12: Plan de câblage

La dernière étape consiste à brancher la carte ESP32 D1 R32 sur le blindage du clavier LCD.

Figure 13 : Partie inférieure du boîtier avec l'ensemble complet

Maintenant, il suffit de mettre le couvercle et de monter les boutons des potentiomètres, puis notre générateur de fonctions est prêt à l'emploi. Pour l'alimentation électrique, nous pouvons utiliser soit un chargeur USB, soit une alimentation de 6 à 12 V.

Figure 14 : Générateur de fonctions finies sur un oscilloscope


Bonne chance pour la reconstruction.

Lien vers l'article du blog au format PDF