MidiFlower - Musik mit Pflanzen

Wir haben im Juli 2025 ein Kit für eine MidiFlower erhalten. Basierend auf der französischen Originaldokumentation hier eine eingedeutschte Kopie.

Arduino IDE und ESP32 flashen

Deutsche Dokumentation der Originalquelle: http://wikifab.org/wiki/Capteur_BioData_pour_ESP32

IMG_20250806_172027.jpg

Arduino IDE

Wir arbeiten mit der IDE Version 2.3.6.. Siehe https://www.arduino.cc/en/software. Wir installieren außerdem python3-serial, um die USB-Verbindung über die IDE zuzulassen:

sudo apt install python3-serial
wget https://downloads.arduino.cc/arduino-ide/arduino-ide_2.3.6_Linux_64bit.AppImage
chmod +x arduino-ide_2.3.6_Linux_64bit.AppImage
mv arduino-ide_2.3.6_Linux_64bit.AppImage /opt/

ESP32 Boards

Fügen Sie den ESP32 zur Arduino-IDE hinzu, indem Sie die Zeile https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json hinzufügen:

grafik.png

Laden Sie die ESP32-Erweiterung mit dem Board-Manager herunter:

grafik.png

Bibliotheken installieren

Notwendige Bibliotheken und Versionen:

grafik.png grafik.png

grafik.png

Kompilieren und Hochladen

Außerdem manuell das Projekt in deinen Library-Ordner (z.B. ~/Arduino/libraries/MidiFlower-0.2.0/) entpacken

Kompilieren Sie den Sketch für einen ESP32 und laden Sie ihn auf den ESP32 hoch. (Möglicherweise müssen Sie die Taste „Boot” drücken, um den Upload durchzuführen. Siehe Dokumentation des ESP32). Der Sketch ist hier verfügbar:

USB-Anschluss

Falls auf über USB nicht auf den Controller zugegriffen werden kann, fehlen u.U. die passenden Berechtigungen. Dies lässt sich wie folgt beheben:

sudo usermod -a -G dialout $(whoami)

Falls dies nicht ausreicht:

sudo vim /etc/udev/rules.d/99-usb-serial.rules
KERNEL=="ttyACM[0-9]*", SYMLINK+="ttyUSB%n", GROUP="dialout", MODE="0660"
sudo udevadm control --reload-rules
sudo udevadm trigger

Falls dies immer noch nicht ausreicht ein dreckiger Trick:

sudo chmod 666 /dev/ttyUSB0

Modul-Auswahl, Partitionierung, Hochladen

Unser Modul hat folgende Specs:

Folgendes Partitionierungsschema ist für's Flashen wichtig: No OTA (2MB App / 2MB SPIFFS)
Folgendes Partitionierungsschema ist für's Flashen wichtig: Default 4MB with spiffs (1.2MB APP/1.5MB SPIFFS)

grafik.png

Wir selbst nutzen für unseren Flashing Vorgang ein ESP32 Dev Kit C von AZ-Delivery. Dies entspricht in Arduino IDE dem Entwicklerboard ESP32 Wrover Module oder ESP32-WROOM-DA. Wir flashen bei einer Baudrate von 115200.

Bildschirmfoto_20250806_192704.png

Flashing überprüfen

Über den Serial Monitor unter Tools können wir bei angeschlossenen USB-Port überprüfen, was die Ausgabe des Controllers ist. Mit Baudrate 115200 erhalten wir u.U. folgenden Output:

st:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0030,len:4980
load:0x40078000,len:16612
load:0x40080400,len:3480
entry 0x400805b4
E (229) esp_core_f�[}���͡� Incorrect size of core dump image: 1

u.U. stimmt hier das Partitionierungsschema nicht. Überpüfen und neu kompilieren!

Hinweise und Referenzen

Dieses Tutorial wurde dank der Arbeit von Sam Cusumano electricityforprogress https://github.com/electricityforprogress/MIDIsprout erstellt. Die Originalarbeit von Sam unterliegt der Open-Source-Lizenz „MIT Licence”.

BioData-Sensor für ESP32 - DIY ohne Fertigplatine

Deutsche Dokumentation der Originalquelle: http://wikifab.org/wiki/Capteur_BioData_pour_ESP32

grafik.png

Einführung

Das Ziel dieses Tutorials ist der Bau des Biodata-Sensors von Sam Cusumano (https://github.com/electricityforprogress/MIDIsprout) für die Verwendung mit einem ESP32.Der ESP32 ermöglicht es dann, die an der Pflanze vorgenommenen Messungen zu interpretieren und sie in Bluetooth-Midi-Frames an einen Synthesizer zu übertragen.

Schritt 1 – Benötigtes Material

Schritt 2 – Einbau des IC 555

Beachten Sie zunächst, dass die Anschlüsse der Testplatine mit Zahlen und Buchstaben gekennzeichnet sind. Die Spalten an der Seite sind ebenfalls mit + und - gekennzeichnet. Positionieren Sie dann die Komponente 555 auf der Testplatine und achten Sie dabei auf die Position der 555 auf der Testplatine. Achten Sie auf die Ausrichtung des 555, die kleine runde Markierung auf dem Bauteil muss nach oben zeigen.

grafik.png

Schritt 3 – Stromversorgung des 555 hinzufügen

Ein schwarzer Draht zwischen a2 und der Masseleitung. Ein roter Draht zwischen a5 und der +5V-Leitung.

grafik.png

Schritt 4 – Versorgungskondensatoren

Positionieren Sie die Kondensatoren 1μf und 47μf.

Achtung: Der Kondensator 47μf hat eine bestimmte Ausrichtung, der längere Anschluss (+) muss nach rechts zeigen.

grafik.png

Schritt 5 – Zeitkondensatoren

Setzen Sie den Kondensator 0,0047μf zwischen b2 und b3 ein.

grafik.png

Schritt 6 – Verkabelung

grafik.png

Schritt 7 – Widerstand

Positionieren Sie einen Draht zwischen h3 und f11. Positionieren Sie den 100k-Widerstand zwischen der Leitung + und h11.

grafik.png

Schritt 8 – Ausgang des 555

grafik.png

Schritt 9 – Anschluss des Sensors an die Pflanze

Schließen Sie die Pflanze an j3 und j4 an. Die Elektroden an der Pflanze können einfach 5cm abisolierte Elektrokabel sein. Wickeln Sie das abisolierte Kabel um einen Stab.

grafik.png

Schritt 10 – ESP32 anschließen

grafik.png

 

BioData-Sensor für ESP32 – PCB MidiFlower

Quelle der Originaldokumentation: https://wikifab.org/wiki/Capteur_BioData_pour_ESP32_-_PCB_MidiFlower

1.png

Schritt 1 - Anschließen des ESP32 an den Sensor

Schritt 2 - Programmierung des ESP32

Sie können das vorherige Tutorial fortsetzen, in dem angegeben ist, wie Sie das Programm in den ESP32 hochladen können

2 verschiedene Programme für ESP32 finden sich hier:

Eine Verwendung mit dem neuen Raspberry PI PICO findet sich hier:

Weitere Projekte, die die Verwendung des Sensors veranschaulichen, finden sich ebenfalls hier:

Bluetooth BLE Midi - Anwendungen (Apps)

Ubuntu

FluidSynth Midi Synthesizer

sudo apt install fluidsynth fluid-soundfont-gs alsa-utils qsynth

Apple iOS

GarageBand

Android

Anwendungen, um per Bluetooth einen Midi-Port bereit zu stellen

Wir benötigen ein Programm zum Mappen von Midi-Ports aus Bluetooth-Geräten. Hierfür eignet sich zum Beispiel: Bluetooth MIDI Connect

Screenshot_20250811-173326_bluetooth.midi.connect.png

Anwedungen, um Instrumente auf verfügbare Midi-Ports zu legen

Neben einem verfügbaren Midi-Port benötigen wir eine App zum Abspielen der Tonfolgen, die über das Interface geschickt werden. Hierfür empfiehlt sich FluidSynth MIDI Synthesizer oder Piano MIDI BLE USB.

Piano MIDI BLE USB

Screenshot_20250806-201517_Piano MIDI BLE USB.png Screenshot_20250806-201603_Piano MIDI BLE USB.png

FluidSynth MIDI Synthesizer

Auch auf Github verfügbar: https://github.com/FluidSynth/fluidsynth

grafik.png Screenshot_20250806-192901_FluidSynth MIDI.png

Far-Feuille-Eu –  Schall- und Lichtwellen durch elektrische Aktivität von Pflanzen

Quelle: Far-Feuille-Eu - Son et lumière généré par l'activité électrique d'une plante

grafik.png

Einleitungsvideo

Schritt 1 – Biodata-Sensor bauen

grafik.png

Je nach Ihrer Erfahrung benötigen Sie zwischen einer Stunde und einem halben Tag, um den Biodatensensor zusammenzubauen, zu testen und in Betrieb zu nehmen, mit dem jede Bluetooth-Synthesizer-Anwendung mit einer Pflanze verbunden werden kann. Beginnen Sie mit der Anleitung von Stéphane Godin und bauen Sie diesen Sensor.

Schritt 2 – Starten Sie den 3D-Druck

Mesurez votre pot de fleur et les dimensions nécessaires pour pouvoir intégrer votre plante, puis allez chercher le fichier pour le socle, et le fichier pour le dôme.

Messen Sie Ihren Blumentopf und die erforderlichen Abmessungen, um Ihre Pflanze unterbringen zu können, und suchen Sie dann die Datei für den Sockel und die Datei für die Kuppel:

Passen Sie die Abmessungen und die Ausrichtung an, um zwei Ausdrucke vorzubereiten. Der Sockel kann im Vergleich zu den anderen Abmessungen X und Y um 50 % in der Z-Achse verkleinert werden, um das Modell zu „verdichten”. Der Druckvorgang kann sehr lange dauern. Die Volumen sind relativ dünn, sodass Sie eine hohe Füllrate (>50 %) festlegen können. Starten oder planen Sie Ihre 3D-Drucke und fahren Sie mit dem Rest dieses Tutorials fort.

grafik.png grafik.pnggrafik.png

Schritt 3 – Fertigen Sie die Reflektoren an

Sie benötigen eine Schere, Klebestift und Aluminiumfolie. Schneiden Sie kleine Streifen aus, die den Mustern des Sockels folgen.bHier hat das Team von Far-Feuille-Eu auch einen Rand am unteren Rand der Kuppel angebracht, ähnlich einem reflektierenden „Saturnring”. Kartonbasis und Aluminiumfolie. Kleben Sie Ihre Reflektoren sorgfältig in die Rillen des Sockels. Sie können auch versuchen, einen reflektierenden Ring am unteren Rand der Kuppel anzubringen.

grafik.png  grafik.png

Schritt 4 – Löten und verbinden Sie die RGB-LEDs

Wie im Quellcode von Schritt 5 zu sehen ist, müssen die RGB-LEDs an die nummerierten Pins des ESP32 Controllers angeschlossen werden. Es müssen jedoch auch drei mit drei RGB-LEDs verlötete Bänder hergestellt werden, die an die ESP32-Karte angeschlossen werden. Dies kann anhand der Prototyping-Platine erfolgen, die zur Herstellung des Biodatensensors verwendet wird.

Auf dem Prototyping-Board muss ein Widerstand von 220 K pro Farbstift auf RGB-LEDs vorgesehen werden. Die Masse der LEDs ist mit GND des ESP32 verbunden. Diese Anleitung kann Ihnen helfen, wenn Sie noch nie eine RGB-LED an einen Arduino angeschlossen haben.

Die drei LEDs dieses Prototyps sind wie folgt verdrahtet:

#define PIN1_RED 25 // GIOP25
#define PIN1_GREEN 26 // GIOP26
#define PIN1_BLUE 27 // GIOP27
#define PIN2_RED 35 // GIOP35
#define PIN2_GREEN 32 // GIOP32
#define PIN2_BLUE 33 // GIOP33
#define PIN3_RED 36 // GIOP36
#define PIN3_GREEN 39 // GIOP39
#define PIN3_BLUE 34 // GIOP34

Wenn Sie die Anleitung zur Herstellung des Sensors von Stéphane Godin befolgt haben, verwenden Sie dasselbe ESP32-wroom-Modul. Das letzte Bild zeigt Ihnen, wo Sie Ihre LEDs anschließen müssen. Sie können alle Massen der LEDs mit der Masse (GND) der ESP32-Karte verbinden. Anschließend können Sie Tests durchführen, müssen aber noch Ihre LED-Bänder in die Kuppelstruktur integrieren, beispielsweise mit Klebeband.

Wenn Ihnen das gelingt, haben Sie die Kuppel der Far-Feuille-Eu gebaut!

grafik.png grafik.png grafik.png grafik.png grafik.png

Schritt 5 – Arduino Quellcode integrieren und ESP32-Modul flashen

Nachfolgend finden Sie den von Jacques während des Hackathons entwickelten Quellcode.

Sie können diese .ino-Datei auch herunterladen und mit der Arduino-Software öffnen, wobei Sie dieselben Einstellungen wie in der Anleitung von Stéphane Godin verwenden, und sie dann an den ESP32 zu laden.

#define PIN1_RED 25 // GIOP25
#define PIN1_GREEN 26 // GIOP26
#define PIN1_BLUE 27 // GIOP27
#define PIN2_RED 35 // GIOP35
#define PIN2_GREEN 32 // GIOP32
#define PIN2_BLUE 33 // GIOP33
#define PIN3_RED 36 // GIOP36
#define PIN3_GREEN 39 // GIOP39
#define PIN3_BLUE 34 // GIOP34

#define R_channel 0
#define G_channel 1
#define B_channel 2

#define pwm_frequency 5000 // frequence pwm
#define pwm_resolution 8 // 8 bit resolution

//##############################
void setup()
{
  pinMode(PIN1_RED,   OUTPUT);
  pinMode(PIN1_GREEN, OUTPUT);
  pinMode(PIN1_BLUE,  OUTPUT);

  pinMode(PIN2_RED,   OUTPUT);
  pinMode(PIN2_GREEN, OUTPUT);
  pinMode(PIN2_BLUE,  OUTPUT);

  pinMode(PIN3_RED,   OUTPUT);
  pinMode(PIN3_GREEN, OUTPUT);
  pinMode(PIN3_BLUE,  OUTPUT);


  ledcAttachPin (PIN1_RED, R_channel);
  ledcAttachPin (PIN1_GREEN, G_channel);
  ledcAttachPin (PIN1_BLUE, B_channel);

  ledcAttachPin (PIN2_RED, R_channel);
  ledcAttachPin (PIN2_GREEN, G_channel);
  ledcAttachPin (PIN2_BLUE, B_channel);
  
  ledcAttachPin (PIN3_RED, R_channel);
  ledcAttachPin (PIN3_GREEN, G_channel);
  ledcAttachPin (PIN3_BLUE, B_channel);
  
  ledcSetup(R_channel, pwm_frequency,pwm_resolution);
  ledcSetup(G_channel, pwm_frequency,pwm_resolution);
  ledcSetup(B_channel, pwm_frequency,pwm_resolution);

}

void loop()
{
          //Correspondance des frequences des notes en hertz (octave à 0) et la couleurs
          Serial.println (note.value); 
          if (note.value == 36) //Do
          {
          setColor(237, 0, 0); // RGB_Ecarlate
          }
          else if (note.value == 37) //Do# 
          {
          setColor(255, 0, 0); //RGB rouge
          }
          else if (note.value == 38) //Ré_Orange
          {
          setColor(255, 165, 0); //RGB_Ornage
          }
          else if (note.value == 39) //Ré#_Jaune
          {
          setColor(255, 255, 0); //RGB_Jaune
          }
          else if (note.value == 40) //Mi_Citron 
          {
          setColor(0, 255, 0); //RGB_Citron
          }
          else if (note.value == 41) //Fa_Vert
          {
          setColor(0, 128, 0); //RGB_Vert
          }
          else if (note.value == 42) //Fa#_Turquoise
          {
          setColor(0, 206, 209); //RGB_Turquoise
          }
          else if (note.value == 43) //Sol
          {
          setColor(0, 255, 255); //RGB_Cyan
          }
          else if (note.value == 44) //Sol#_Indigo 
          {
          setColor(75, 0, 130); //RGB_Indigo
          }
          else if (note.value == 45) //La_Bleu
          {
          setColor(0, 0, 255); //RGB_Bleu
          }
          else if (note.value == 46) //La#_Pourpre 
          {
          setColor(176, 224, 230); //RGB_Pourpre
          }
          else if (note.value == 47) //Si
          {
          setColor(255, 0, 255); //RGB_Mangenta
          }
 }

void setColor(int R, int G, int B) 
{
ledcWrite(R_channel,R);
ledcWrite(G_channel,G);
ledcWrite(B_channel,B);

}

Schritt 6 – Ton- und Lichttests

  1. Sie müssen auf einem Mobiltelefon mit Bluetooth eine kostenlose Synthesizer-App installieren. Siehe Bluetooth BLE Midi.
  2. Aktivieren Sie dann Bluetooth in den Einstellungen Ihres Smartphones.
  3. Starten Sie schließlich die Synthesizer-App und aktivieren Sie die Auswahl einer Bluetooth-Midi-Quelle.
  4. Wählen Sie „far-feuille-eu”. Sie sollten nun mit der MIDI-Quelle verbunden sein und den Klang der Pflanze hören können.
  5. Durch die Einstellung der Klänge, die den MIDI-Kanälen 1 bis 3 zugewiesen sind, mit dem Synthesizer können Sie die Atmosphäre stark beeinflussen. Die Noten und der Rhythmus werden durch den Arduino-Quellcode definiert.

MUTED – Biodata-Gehäuse für analoges Synthesizer-Modul

Originalquelle: https://wikifab.org/wiki/MUTED_-_boitier_biodata_vers_module_de_synth%C3%A9tiseur_analogique

grafik.png

Gehäuse zum Anschluss einer Pflanze an einen analogen Synthesizer. Prototyp, der vom MUTED-Team während eines Hackathons zur Umwandlung von Biodaten in Musik entwickelt wurde, der Ende 2021 vom Climate Change Lab in Janzé in der Nähe von Rennes organisiert wurde.

Einführung

Dieser Prototyp wurde innerhalb von zwei Tagen in Janzé in der Nähe von Rennes vom MUTED-Team während eines Hackathons entwickelt, dessen Ziel es war, die in einer Pflanze festgestellte biologische Aktivität in eine musikalische Installation umzuwandeln. Um ihn nachzubauen, muss zunächst der im erforderlichen Tutorial beschriebene Sensor hergestellt werden.

Dann eine 3,5-mm-Klinkenbuchse zum Löten (oder aus einem alten Kopfhörerkabel) und eine Box zum Einbau des Geräts.

Achtung: Es funktioniert mit jedem Gerät, das eine Steuerspannung zwischen 0 und 3,3 V akzeptiert (insbesondere alle analogen Synthesizer).

Einleitungsvideo

Schritt 1 – Führen Sie zunächst das Tutorial Biodata-Sensor mit ESP32 durch.

grafik.png

Achtung: Sie müssen zunächst in der Lage sein, eine Pflanze an eine elektronische Karte anzuschließen, um winzige elektrische Schwankungen zu erfassen und umzuwandeln. Dies dauert zwischen zwei Stunden und einem halben Tag, wenn Sie dem Tutorial von Stéphane Godin folgen.

Schritt 2 – Arduino-Quellcode integrieren

grafik.png

Der kompatible Quellcode für den Betrieb des Sensors wird hier aufgerufen. Er muss kompiliert und mit dem Arduino-Tool an das ESP32-Modul gesendet werden.

/*
 MIT License

Copyright (c) 2016 electricityforprogress

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


This project is based on https://github.com/electricityforprogress/MIDIsprout great work about biodata sonification
*/

#include <Arduino.h>

#define SAMPLESIZE  32
#define LED 5
#define DAC1 25

#define DESIRED_EVENT 6
#define ARRAYLEN(a) ((sizeof(a))/(sizeof(a[0])))

//manage LEDs without delay() jgillick/arduino-LEDFader https://github.com/jgillick/arduino-LEDFader.git
void sample();
float mapfloat(float x, float in_min, float in_max, float out_min, float out_max);
void analyzeSample();





//******************************
static byte state;
//*******************************

const byte interruptPin = 12; //galvanometer input

byte samplesize = SAMPLESIZE / 2; //set sample array size
//const byte analysize = SAMPLESIZE - 1;  //trim for analysis array


int CVmod = 0;





volatile unsigned long microseconds; //sampling timer
volatile byte sindex = 0;
volatile unsigned long samples[SAMPLESIZE];

float threshold = 1;  //change threshold multiplier


unsigned long previousMillis = 0;
unsigned long currentMillis = 1;
unsigned long batteryCheck = 0; //battery check delay timer

uint32_t threshold_last_millis = 0;
unsigned int  threshold_evt = 0;



//std::vector<CSequence*> psequences;

uint32_t sequence_time = 0;
uint16_t sequence_index = 0;
uint32_t chipId = 0;

char bleserverid[64] = "";
void setup()
{

  for(int i=0; i<17; i=i+8) {
    chipId |= ((ESP.getEfuseMac() >> (40 - i)) & 0xff) << i;
  }


  pinMode (LED, OUTPUT);    // initilize led output
  digitalWrite(LED, HIGH);   // set led ON

  sprintf (bleserverid, "BioData_%08lx MIDI device", chipId);
 // BLEMidiServer.begin(bleserverid); // initialize bluetooth midi
  Serial.begin(115200);                       //initialize Serial for debug


  
  attachInterrupt(interruptPin, sample, RISING);  //begin sampling data from interrupt

}

void loop()
{
  currentMillis = millis();   //manage time

  if(sindex >= samplesize)  { analyzeSample(); }  //if samples array full, also checked in analyzeSample(), call sample analysis
 

  if (currentMillis - threshold_last_millis > 15000)
  {

      if (threshold_evt < DESIRED_EVENT)
      {
        if (threshold > 0.001)
          threshold /= 1.4;
      }
      else
      {
        if (threshold < 10)
          threshold *= 1.4;
      }
      threshold_last_millis = currentMillis;
      threshold_evt = 0;
      //Serial.println(threshold);
  }


}




//interrupt timing sample array
void sample()
{
  if(sindex < samplesize) {
    samples[sindex] = micros() - microseconds;
    microseconds = samples[sindex] + microseconds; //rebuild micros() value w/o recalling
    //micros() is very slow
    //try a higher precision counter
    //samples[sindex] = ((timer0_overflow_count << 8) + TCNT0) - microseconds;
    sindex += 1;
  }
  digitalWrite(LED, ((state) & 0x01) == 0 ? HIGH : LOW);
  state++;


}



void analyzeSample()
{

  //eating up memory, one long at a time!
  unsigned long averg = 0;
  unsigned long maxim = 0;
  unsigned long minim = 10000000;
  float stdevi = 0;
  unsigned long delta = 0;
  byte change = 0;

   digitalWrite(LED, ((state) & 0x01) == 0 ? HIGH : LOW);
  state++;
  if (sindex >= samplesize) { //array is full
    unsigned long sampanalysis[SAMPLESIZE];
    for (byte i=0; i < samplesize; i++){
      //skip first element in the array
      sampanalysis[i] = samples[i];  //load analysis table (due to volitle)
      //manual calculation
      if(sampanalysis[i] > maxim) { maxim = sampanalysis[i]; }
      if(sampanalysis[i] < minim) { minim = sampanalysis[i]; }
      averg += sampanalysis[i];

    }
    averg = averg / (samplesize);
    for (byte i = 0; i < samplesize; i++)
    {
      stdevi += (sampanalysis[i] - averg) * (sampanalysis[i] - averg) ;  //prep stdevi
    }

    //manual calculation

    stdevi = stdevi / (samplesize);
    if (stdevi < 1) { stdevi = 1.0; } //min stdevi of 1

    stdevi = sqrt(stdevi); //calculate stdevu

    delta = maxim - minim;


    //Serial.printf("%ld %ld %ld %ld %f %f\r\n", minim, maxim, averg, delta, stdevi, stdevi * threshold);
    Serial.printf("%ld", delta);
    //Serial.print(averg);
    Serial.println(",");
    CVmod = map(delta, 0, 20000, 0, 255);
    Serial.println(CVmod);
    
    int data2 = delta % 255;
    Serial.println(data2);
    dacWrite(DAC1, data2);

    sindex = 0;

  }
}

Schritt 3 – Anschlüsse überprüfen

grafik.png

Die Masse Ihres Audiokabels muss an den GND-Pin des ESP32 angeschlossen werden.

Der andere Draht muss an den GPIO-Pin 25 angeschlossen werden. Das Modul verfügt nämlich über zwei Pins, die automatisch die Umwandlung „Digital Analogic Converter” vornehmen, die Pins GPIO 25 und 26. Dies geschieht in einem Bereich zwischen 0 und 3,3 V.

Um die Funktion zu testen, können Sie ein Multimeter nehmen und es an zwei Abschnitten des Klinkensteckers anlegen. Normalerweise messen Sie eine variable Spannung zwischen 0 und 3,3 V.

Schritt 4 – Das Modul an einen Synthesizer anschließen

grafik.png

Jetzt müssen Sie nur noch das an eine Pflanze angeschlossene Gehäuse mit Strom versorgen (zwei abisolierte Kabel an zwei Stäben) und den Stecker einstecken, um ein lebendes Modul in Ihren Synthesizer zu integrieren.

Ein großes Dankeschön an Simon Lamy für die bereitgestellten Informationen und die Medienelemente dieses Tutorials!

Notizen und Referenzen