Überwachung durch Vibration (Arduino)

[Simon (Gast)]

Hallo Liebe Community!

Ich möchte ein Projekt starten, bin im Umgang mit dem Arduino Neuling.

Mein Ziel:
- Erfassung von Vibrationen von Anlagen
- Aufzeichnung in einer Messkurve
- Abrufen der erfassten Daten

Nun zu meiner Frage:
Ist es möglich, durch z.B. einen Vibrationssensor den Rundlauf einer 
mechanischen Anlage aufzuzeichnen und zu bewerten?

Die Aussagekraft soll sein:
- Vibrationsbereiche und Messkurve immer gleich: die Anlage funktioniert 
ordnungsgemäß

- Vibrationsbereiche und Messkurve zeichnen Abweichungen auf: die Anlage 
ist wartungsbedürftig, da z.B. mechanische Lager ausgeschlagen sind etc.

Ist das Projekt realistisch?

MfG Simon
Danke für eure Antworten!

[Klausi (Gast)]

Simon schrieb:
> Ist das Projekt realistisch?

Ja

[Basti B. (basti195)]

Zunächst einmal ist sowas natürlich möglich.
Hast du bereits einen Vibrationssensor? Ansonsten kannst du einen 
Regulären 3-Achsen Beschleunigung Sensor nehmen.
Du musst jedoch beachten wie stark das System Vibriert und mit welcher 
Frequenz.

[IGBT (Gast)]

Da braucht es wohl mehr. Welchen Sensor verwendest Du?
Es gibt Sensoren die brauchen einen rausch- und driftarmen 
Vorverstärker.
Grundsätzlich musst Du Dir Gedanken über die Sample Rate machen. Sonst 
versäumst Du die eine oder andere Spitze.
Gegen Einwurf entsprechender Münzen gibt es schöne Systeme mit 
Alarmierung.

[Simon (Gast)]

Danke für die schnellen Antworten!

Grundsätzlich schön, dass so ein Projekt realistisch ist!

Nun zu dem Vibrationssensor:
Ich habe gedacht, ich könne einen einfachen LDT0-028 nehmen, durch den 
ich dann verschiedene Frequenzen aufzeichnen könnte und sie dann z.B. in 
einer Messkurve in einem Webinterface darstellen könnte.

Klingt aber ja so als wäre das nicht so einfach möglich.

Wäre schön wenn mir einer von euch sagen könnte, was ich an Bauteilen 
brauche, muss mich dann anschließend erstmal ausgiebig mit der 
Programmierung eines Arduinos befassen...

Ein fertiges System zu nehmen kommt übrigens nicht in Frage, wird ein 
Abschlussprojekt.

Danke, Gruß Simon

[Thomas W. (Gast)]

Moin, -

Anfang des Jahres (2021) hatte ST Micro ein Webinar ueber "Ultra-wide 
bandwidth, low-noise, 3-axis digital vibration sensor". Da sind Videos, 
SW, Datasheets und Beispiele vorhanden.

https://www.st.com/en/mems-and-sensors/iis3dwb.html

Gruesse

Th.

[Olaf (Gast)]

> Klingt aber ja so als wäre das nicht so einfach möglich.

Naja, die Definition von "Einfach" ist halt immer so eine Sache. :-)

Laut Datenblatt geht das Teil wohl so bis 300Hz und liefert
erstaunlich viel Ausgangssignal.

Ich wuerde da fuer den ersten Versuch einen hochomigen Spannungsteiler
vorsehen, dann einen OPV dessen Verstaerkung du aendern kannst und
erstmal auf 1 einstellst, der aber die Impedanz wandelt. Eventuell noch
eine Schutzdiode an den Eingang.

Dann sampelst du mit 1khz und machst in Software eine FFT.

Ansonsten heisst das geheime Zauberwort fuer Google "Ladungsverstaerker"

Olaf

[STK500-Besitzer (Gast)]

Simon schrieb:
> Ist das Projekt realistisch?

Macht jede Wuchtbank.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Simon schrieb:
> Mein Ziel:
> - Erfassung von Vibrationen von Anlagen
> - Aufzeichnung in einer Messkurve
> - Abrufen der erfassten Daten
Soweit ganz einfach.

> Nun zu meiner Frage:
> Ist es möglich, durch z.B. einen Vibrationssensor den Rundlauf einer
> mechanischen Anlage aufzuzeichnen und zu bewerten?
Ob es funktioniert, hängt von der jeweiligen Anwendung ab. Du musst 
dafür einige Messungen machen und begutachten, um Gemeinsamkeiten und 
Unterschiede bei guten und defekten bzw. beschädigten Maschinen zu 
finden. Wenn du dann anhand der Messwerte eine gute 
Maschine/Anlage/Achse von einer Schlechten unterschieden kannst, kannst 
du bewerten, ob die Rechenleistung des Arduino für die Analyse des 
Datenstroms ausreicht.

Für diese vorbereitenden Messungen ist ausgeschlafenes Equipment nötig, 
denn du musst ja viel mehr erfassen, als der Ardunio dann später sehen 
und auswerten wird. Um es überspitzt zu sagen: der Arduino wird später 
durch ein kleines Guckloch genau auf die interessante Stelle der 
Maschine und der daran ermittelten Daten schauen, du musst dir vorher 
aber ein Gesamtbild auch der Umgebung machen, um genau diese richtige 
Stelle und die optimale Position des Gucklochs zu finden.

> Ist das Projekt realistisch?
Es ist das übliche Monitoring. In der Regel kann aber ein üblicher 
Anwender anhand der Kurvenform einer Achsbewegung nicht erkennen, ob 
diese Kurve gut oder schlecht ist, weil die nötige Information irgendwie 
irgendwo in der Kurve vergraben ist.

STK500-Besitzer schrieb:
> Simon schrieb:
>> Ist das Projekt realistisch?
> Macht jede Wuchtbank.
Eine Wuchtbank ist darauf spezialisiert, solchen unrunden Lauf 
anzuzeigen. Jede andere Erschütterung usw. ist dafür aus dem Messaufbau 
entfernt.

Der Witz hier ist aber, dass "das Projekt" die Unwucht quasi auf dem 
Feldweg messen und erkennen will...

[jo (Gast)]

Mach dich mal bei den Spezialisten (z.B. Bruel & Kjaer) schlau, was du 
da so an Empfindlichkeit, Frequenzbereich und Aufzeichnugsdauer zu 
erwarten hast.

Die Daten wirst Du sicher nicht erreichen, aber ein Hinweis, wo du mit 
deiner Idee stehst - dafür ist das allemal gut...

https://www.all-electronics.de/elektronik-entwicklung/so-funktioniert-schwingungsmessung-technik-und-mess-systeme.html 
oder
https://www.mmf.de/vm-doc/schwingungsmessung_1.htm könnte auch hilfreich 
sein.

"Aus dem hohlen Bauch" würde ich sowas keinesfalls designen wollen.

[Wolfgang (Gast)]

IGBT schrieb:
> Grundsätzlich musst Du Dir Gedanken über die Sample Rate machen. Sonst
> versäumst Du die eine oder andere Spitze.

Die nächste Spitze kommt bestimmt. Also keine Panik, wenn man eine mal 
nicht mitbekommt. Ob Aliasing stört, ist eine andere Frage.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Webinterface ist mit einem kleinen Arduino aber ein Killerargument. Das 
schafft ein Arduino aus der AVR Familie sicher nicht, wenn er 
gleichzeitig Messwerte erfasst und FFT machen soll.

[STK500-Besitzer (Gast)]

Lothar M. schrieb:
> Eine Wuchtbank ist darauf spezialisiert, solchen unrunden Lauf
> anzuzeigen. Jede andere Erschütterung usw. ist dafür aus dem Messaufbau
> entfernt.


Simon schrieb:
> - Erfassung von Vibrationen von Anlagen
Ich hatte mich etwas kurzgefasst, und meinte eine Untermethode der 
Unwuchtfeststellung:
https://de.wikipedia.org/wiki/Betriebswuchten

Als Sensor benutzt man auch gerne Piezo-Keramiken.
Ältere Wuchtbänke verwenden induktive Aufnehmer.
Die Firmen Schenck und Hofmann sind in Deutschland dafür Marktführer.
Ich hatte auch mit einer Firma aus NRW zu tun, die ein Handgerät zur 
Schwingungsmessung (optional mit zweitem Sensor) anbot.
Wie die hieß habe ich leider vergessen.

Um die Geräusche von Geräten (Lüfterrauschen etc.) zu messen, werden 
ziemlich oft Geräte von Bruel&Kjaer verwendet.
Das sind aber dann eher Mikrofone.

[Manfred H. (protolus)]

Ich persönlich würde statt eines Vibrationssensors lieber ein Mikrofon 
(oder mehrere) verwenden. Ich vermute, dass sich schädliche Änderungen 
eher im Geräusch als in den Schwingungen ankündigen.

So oder so wirst Du um eine FFT-Analyse nicht herumkommen. Aus den 
Messdaten eine „Messkurve“ abzuleiten und aus der wiederum Veränderungen 
geht m.E. nicht ohne FFT.

Ich würde das Problem folgender Massen angehen:

Die Daten mit einem ESP32-Mikrokontroller-Board erfassen und per 
UDP-Protokoll an einen PC übertragen.

Der ESP32 hat WiFi und BlueTooth an Board, arbeitet mit 32 Bit und ist 
damit sehr Leistungsstark und zudem kompatibel zur Arduino-IDE. Er hat 
zwei Cores und nennenswert Speicher. Zudem hat er eine Taktfrequnz von 
nominal 80 MHz und seine AD-Wandler mit 1uS sample-time ziemlich 
schnell.  Mit den zwei Cores kannst Du einen kontinuierlichen Datenstrom 
aufrecht erhalten. Während auf dem einen Core die Samples laufen kann 
der zweite Core gleichzeitig die Datenübertragung abwickeln. Die 
Software für zwei Cores zu erstellen kling kompliziert ist aber im 
Arduino-IDE überraschend einfach.

Die Messdaten direkt auf den PC zu übertragen und erst dort die 
FFT-Analyse und die Auswertung durchzuführen hat den Vorteil, dass der 
PC trotz allem schneller ist und Du je nach verwendeter 
Programmiersprache mehr Möglichkeiten, was Speicher, Auswertung, 
Webpage, Grafik usw anbelangt, hast.

Es existiert eine FFT-Cx-Library, die sehr umfangreich und trotzdem 
leicht zu handhaben ist. Du musst Dich halt ein wenig mit „bins“ 
beschäftigen.

Hier der Link zu dieser Library:

https://heliso.tripod.com/programm/fft/fftdll.htm

Stell Dir das Problem nicht zu einfach vor. Die Anlagen werden nicht 
einheitliche Messdaten liefern. Wenn die Anlage zyklisch wiederkehrende 
gleiche Arbeitsschritte macht, ist es etwas einfacher. Ist die 
Reihenfolge der "Arbeitsschritte" aber quasi „chaotisch“ wird es 
schwierig, da eine schadhafte Veränderung herauszufiltern.
Ich fürchte, da wirst Du um ein Faltungs Neuronales Netz nicht 
herumkommen.
Aber lass Dich nicht entmutigen. Wir wachsen mit unseren Aufgaben.

Und hier der Code eines Arduino-Sketches für ESP32, der die 
Spannungswerte, die von einem Mikrophon kommen, digitalisiert und eine 
FFT-Analyse durchführt. Die Ergebnisse der FFT-Analyse werden per UDP an 
einen PC übertragen und dort ausgewertet (Spracherkennung). Der Sketch 
ist getestet und läuft einwandfrei.
Trotz UDP werden die Daten schön in Reihenfolge übertragen. TCP/IP hat 
sich als zu langsam herausgestellt.

Core 1 sampelt die Messdaten, Core 0 managed die FFT-Analyse und die 
Übertragung zum PC.

Du kannst den Code abändern und die FFT-Analyse überspringen und die 
Messdaten direkt an den PC übertragen.

/*
#
*  Dieser Sketch sampelt Daten von einen ADC-Input, führt damit eine FFT-Analyse durch und überträgt das Ergebnis per UDP zu einem Server.
// Core 1: Sampling: Core 0: FFT und UDP-Übertragung
 *
 */

#include <WiFi.h>
#include <WiFiUdp.h>

#include <Wire.h>
#include "arduinoFFT.h" // Standard Arduino FFT library https://github.com/kosme/arduinoFFT
arduinoFFT FFT = arduinoFFT();

const char* ssid     = "FlyingDutchman";
const char* password = "*********************************";

const char* host = "192,168,178,24";

int Verbunden;
int pingResult;

////////////////////////////////////////////////////////////////
#define SAMPLES 512              // Must be a power of 2
#define SAMPLING_FREQUENCY 10000 // Hz, must be 40000 or less due to ADC conversion time. Determines maximum frequency that can be analysed by the FFT Fmax=sampleF/2.
#define amplitude 150            // Depending on your audio source level, you may need to increase this value
#define LED_GREEN        27
#define mitte            2800
#define oBufSize         1024

const int httpPort = 50000;
const int ownPort = 50000;

unsigned int sampling_period_us;
unsigned long microseconds;
byte peak[] = {0,0,0,0,0,0,0,0};
double t0_vReal[SAMPLES];
double t0_vImag[SAMPLES];
double t1_vReal[SAMPLES];
double t1_vImag[SAMPLES];
unsigned long newTime, oldTime;
int dominant_value;
byte oBuf[oBufSize];
int erg;
double maxi;
int mini;
byte tp;
byte indi;
long sum;
int ave;
long th;
byte swi;
byte swi2;
long setPnt;
byte setActive;
long zh;
byte prea[6] = {123,205,007,197,0,0};
byte ack[2];
long cnt;
long mwe;
long z1;
long z2;

TaskHandle_t  Core0TaskHnd ;  

/////////////////////////////////////////////////////////////////////////

WiFiClient client;
WiFiUDP udp;

void setup()
{

    xTaskCreatePinnedToCore(CoreTask0,"CPU_0",1200,NULL,1,&Core0TaskHnd,0);
  
    sampling_period_us = round(1000000 * (1.0 / SAMPLING_FREQUENCY));
  
    Serial.begin(115200);
    delay(10);

    // We start by connecting to a WiFi network

    Serial.println();
    Serial.println();
    Serial.print("Connecting to ");
    Serial.println(ssid);

    WiFi.begin(ssid, password);
    int cnt=0;
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
        cnt++;
        if(cnt=10){
          break;
        }
    }
    delay(1000);
    Serial.print("Erneuter Versuch");
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }

    Serial.println("");
    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    Serial.println(WiFi.localIP());
    delay(500);
    Serial.print("connecting to ");
    Serial.println(host);
    Serial.println("Version; FFT_UDP_02");
    pinMode(LED_GREEN, OUTPUT);
    digitalWrite(LED_GREEN, HIGH);
    int ret = udp.begin(ownPort);
    cnt = 0;
    Serial.println(" ");
    Serial.println("Vers.: Sprache Aufnehmen, FFT und Ergebnis nach PC (MSP32)");
    Serial.println("Auf PC starten auf Base, Button Start UDP");
    Serial.println("FFT_UDP_02");
    Serial.println(" ");
}

void loop()
{
  sum = 0;
  for (int i = 0; i < SAMPLES; i++)
  {
    newTime = micros();
    int we = analogRead(A0); // Using Arduino ADC nomenclature. A conversion takes about 1uS on an ESP32
    
    // Fill the corresponding Buffer
    if(tp == 0)
    {
      t0_vReal[i] = we;
      t0_vImag[i] = 0;
    }
    else
    {
      t1_vReal[i] = we;
      t1_vImag[i] = 0;
    }

    //Update sum for average calculation
    if(we >= mitte)
    {
      sum = sum + (we - mitte);
    }
    else
    {
      sum = sum + (mitte - we);
    }

    while ((micros() - newTime) < sampling_period_us)
    { /* do nothing to wait */
    }
  }
  
  zh = micros();
  //calculate average
  ave = sum / SAMPLES;
  //Serial.println(ave,DEC);
  
  if(ave > 210)
    {    
      digitalWrite(LED_GREEN, LOW);
      swi = 0;
      if(swi2 == 0)
      {
        // Trigger speach
        //Activate FFT-Processing
        swi2 = 1;
        setPnt = 0;
        setActive = 1;
      }
    }
    else
    {
      if(swi == 0)
      {
        swi = 1;
        th = micros(); 
      }
      else
      {
        if(micros() - th > 350000)
        {
          digitalWrite(LED_GREEN, HIGH);
          swi = 0;
          if(swi2 == 1)
          {
            // speech end detected       
            swi2 = 0;
            // fill unused OBuf with Zerro
            setPnt = 0;
            //deactivate FFT-processing
            setActive = 0;
          }
        }
      }
    }
    //Serial.println(micros() - zh,DEC);

  //swap buffer-pointer
  tp = (tp-1) * -1;
  // set indi for data available
  indi = 1;

   //Serial.println(micros() - zh,DEC);
}

void CoreTask0( void * parameter ) 
{ 
  for (;;) 
  { 
    //-----------------------------------------------------
    while(indi == 0)
    {
      vTaskDelay(10); // wait for Sample-Buffer
    }
    indi = 0;
    if(tp == 0)
    {
      FFT.Windowing(t1_vReal, SAMPLES, FFT_WIN_TYP_HAMMING, FFT_FORWARD);
      FFT.Compute(t1_vReal, t1_vImag, SAMPLES, FFT_FORWARD);
      FFT.ComplexToMagnitude(t1_vReal, t1_vImag, SAMPLES);
      //peak = FFT.MajorPeak(t1_vReal, SAMPLES, SAMPLING_FREQUENCY);

      for(int i = 0; i < SAMPLES / 2; i++)
      {
        mwe = t1_vReal[i];  
        
        oBuf[i * 4] = int(mwe / 16777216);
        z1 = mwe % 16777216;
        oBuf[i * 4 + 1] = int(z1 / 65536);
        z2 = z1 % 65536;
        oBuf[i * 4 + 2] = int(z2 / 256);
        oBuf[i * 4 + 3] = int(z2 % 256);
      }
      udp.beginPacket("192.168.178.24", httpPort);
      udp.write(oBuf, oBufSize);
      int ret = udp.endPacket();
    }
    else
    {
      FFT.Windowing(t0_vReal, SAMPLES, FFT_WIN_TYP_HAMMING, FFT_FORWARD);
      FFT.Compute(t0_vReal, t0_vImag, SAMPLES, FFT_FORWARD);
      FFT.ComplexToMagnitude(t0_vReal, t0_vImag, SAMPLES);
      //peak = FFT.MajorPeak(t0_vReal, SAMPLES, SAMPLING_FREQUENCY);

      for(int i = 0; i < SAMPLES / 2; i++)
      {
        mwe = t0_vReal[i];   
        oBuf[i * 4] = int(mwe / 16777216);
        z1 = mwe % 16777216;
        oBuf[i * 4 + 1] = int(z1 / 65536);
        z2 = z1 % 65536;
        oBuf[i * 4 + 2] = int(z2 / 256);
        oBuf[i * 4 + 3] = int(z2 % 256);    
      }
      udp.beginPacket("192.168.178.24", httpPort);
      udp.write(oBuf, oBufSize);
      int ret = udp.endPacket();
    }
    
    //-----------------------------------------------------

    cnt++;
    if(cnt > 50)
    {
      Serial.println(maxi,DEC);
      cnt = 0;
      maxi = 0;
    }
  }
}

[Simon H. (simon_h461)]

Hallo ihr Lieben,
danke für die zahlreichen Antworten,
ich möchte mich erstmal für die späte Antwort entschuldigen.

Nun, ich habe bereits einen ESP32, das passt ja wie die Faust aufs Auge.
Grundsätzlich verstehe ich viele Abkürzungen und deren Bedeutung nicht 
ganz, ich weiß ehrlich gesagt gar nicht wo ich anfangen soll.

@Manfred Danke für den Sketch, werde mich heute Abend hinsetzen und 
versuchen den Code grundsätzlich erstmal zu verstehen. Dann werde ich 
mir Gedanken machen müssen zu der Materialbeschaffung, habe nun oft 
gelesen, dass ein Mikrofon am besten geeignet ist, dann werde ich eins 
bestellen.
Ist grundsätzlich jedes Mikrofon dafür geeignet?
Ist das Iduino 1485297 geeignet?
Gibt es ein besseres?

Werde dann erstmal die Materialien bestellen. Habe jetzt ein Breadboard, 
das wird mir die Arbeit hoffentlich erleichtern.

FFT-Analyse: Keine Ahnung was das ist und wie das funktioniert. Muss ich 
mich befassen und melde mich dann zurück.

Ich bin euch echt für jede Hilfe dankbar, ich bin wie gesagt ein 
absoluter Neuling im Mikrocontroller-Bereich und muss noch viel 
dazulernen...

Gruß, Simon.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Simon H. schrieb:
> ich weiß ehrlich gesagt gar nicht wo ich anfangen soll.
Das mit den von mir erwähnten Grundlagenuntersuchungen hast du hinter 
dir?
Lothar M. schrieb:
>>>> Du musst dafür einige Messungen machen und begutachten, um ...
zu wissen, was du überhaupt auswerten willst.

> ich habe bereits einen ESP32
Vergiss den Rechner. Der kommt erst viel, viel später. Allem voran 
brauchst du ein proof-of-concept: kannst du in dem Signal überhaupt 
irgendwas erkennen? Das kannst du auch am PC mit üblicher Audio-Software 
mal ausprobieren.

> Ist grundsätzlich jedes Mikrofon dafür geeignet?
"Grundsätzlich" schon. Aber Grundlagenuntersuchungen sind 
anerkanntermaßen der völlig falsche Zeitpunkt zum Sparen.
Nimm ein Mikrofon, das einen möglichest linearen und möglichst weiten 
Aufnahmebereich hat. Das Stichwort dazu heißt "Messmikrofon". Und dazu 
ein USB-Audio-Interface als Soundkarte zum Rechner. Oder gleich eines 
mit USB-Schnitte:
https://www.amazon.de/Omnitronic-USB-Kondensator-Messmikrofon-Pr%C3%A4zises-USB-Messmikrofon-Frequenzgang/dp/B078Y59NPT/ref=sr_1_6?keywords=Messmikrofon

> Werde dann erstmal die Materialien bestellen.
Falsche Reihenfolge.

> FFT-Analyse: Keine Ahnung was das ist und wie das funktioniert.
Lass das am Anfang ein Oszilloskop oder den PC machen. Da weißt du 
sicher, dass es funktioniert.

Simon schrieb:
> Ist das Projekt realistisch?
Eines solltest du wissen: für funktionierende Lösungen haben Unternehmen 
viele Mannjahre Arbeitszeit von ausgelernten und erfahrenen Ingenieuren 
und Mathematikern hineingesteckt.
Das macht man nicht nebenher völlig ohne grundlegende Untersuchungen und 
eingehendes Wissen zum Thema "Signalverarbeitung".


BTW: Ein Oszi hat den Vorteil, dass der Messbereich wesentlich weiter 
geht als die Soundkarte des PC...