Arduino Rührwerk mit BLDC Motor

[grotbeck]

Hallo liebes Forum,
ich arbeite aktuell an einem kleinen Rührwerk mit BLDC Motor fürs Bierbrauen. Die Bauteile hatte ich größtenteils noch im Keller und es funktioniert prinzipiell ganz gut. Angeschlossen am Arduino Uno sind ein DS18b20 Sensor, der die Temperatur über das TM1637 Display ausgibt. Ich habe nun allerdings zwei Probleme, bei denen ihr mir vielleicht helfen könnt (vielleicht sind ja hier ein paar Experten im Forum). Zum einen funktioniert der Betrieb mit 9V Netzteil nicht. Es funktioniert nur mit dem USB Kabel am Laptop. Ich verwende ein 9v Gitarrenpedal Netzteil mit 120mA.
Außerdem möchte ich später in einem Phyton Programm einige Daten auswerten (Temperatur, Drehzahl usw…). Aus diesem Grund habe ich den SPEED Ausgang ebenfalls an dem Arduino verbunden (und den GND). Im seriellen Monitor zeigt er aber keine korrekten Werte für die Drehzahl an. Wenn der Motor läuft (egal bei welcher Drehzahl) zeigt er manchmal 0 U/min oder manchmal 30 U/min abwechselnd an. Woran kann das liegen?
Programmcodes und Motortreiber Datenblatt sind im Anhang
Vielen Dank im Voraus!
Liebe Grüße

Code:
#include <TM1637Display.h>
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 2 // Pin für den DS18B20-Sensor
#define CLK 3 // Pin CLK des TM1637-Displays
#define DIO 4 // Pin DIO des TM1637-Displays
#define SPEED_PIN 5 // Pin, an dem der SPEED-Ausgang des Treibers angeschlossen ist
#define MOTOR_POLE_PAIRS 2 // Anzahl der Motorpolpaare

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
TM1637Display display(CLK, DIO);

void setup() {
Serial.begin(9600);
sensors.begin();
display.setBrightness(0x0a); // Helligkeit einstellen (0-0x0f)
pinMode(SPEED_PIN, INPUT); // Den Pin für die Drehzahl als Eingang konfigurieren
}

void loop() {
// Temperatur aktualisieren
sensors.requestTemperatures();
float tempC = sensors.getTempCByIndex(0);

// Drehzahl auslesen
int pulseFrequency = digitalRead(SPEED_PIN);
int motorSpeed = (pulseFrequency * 60) / MOTOR_POLE_PAIRS; // Drehzahl berechnen unter Berücksichtigung der Polpaare

// Temperatur und Drehzahl im Terminal anzeigen
if (tempC != DEVICE_DISCONNECTED_C) {
Serial.print("Temperatur: ");
Serial.print(tempC);
Serial.println(" °C");

Serial.print("Drehzahl: ");
Serial.print(motorSpeed);
Serial.println(" U/min");

int temp = int(tempC);
display.showNumberDec(temp);
} else {
Serial.println("Fehler beim Lesen der Temperatur");
display.showNumberDec(8888);
}

delay(1000);
}

[Fricky]

Vielleicht RS 232 eingestellt statt RS 485?
Nur so ne Idee....

[grotbeck]

Sorry, ich bin noch Neuling in dem Thema, kannst du kurz genauer erläutern was du damit meinst? Danke :-)

Hier auch nochmal kurz skizziert was ich alles verkabelt habe:

[Bitter]

So kann das nicht funktionieren. Du liest in einem Schleifendurchlauf entweder HIGH oder LOW an PIN 5 aus, mit der Information kannst du nichts anfangen, wie du ja selbst festgestellt hast.

void loop() {
...
// Drehzahl auslesen
int pulseFrequency = digitalRead(SPEED_PIN);
int motorSpeed = (pulseFrequency * 60) / MOTOR_POLE_PAIRS; // Drehzahl berechnen unter Berücksichtigung der Polpaare
}

Du musst die Impulse in einem Zeitfenster lesen und dann hochrechnen.

Also z.B.

"letzterZeitpunkt" = millis();
while (("letzterZeitpunkt" + "zeitfenster") > millis())
{
//hier die Impulse zählen
}

Die Breite des Zeitfensters sollte nicht zu groß gewählt werden, da das Programm ja an dieser Stelle verweilt.

Danach kannst du die Motordrehzahl berechnen:

U/"zeitfenster"*60

Dies ist eine Möglichkeit, es gibt sicherlich noch andere!

Gruß Lothar

[grotbeck]

So kann das nicht funktionieren. Du liest in einem Schleifendurchlauf entweder HIGH oder LOW an PIN 5 aus, mit der Information kannst du nichts anfangen, wie du ja selbst festgestellt hast.

void loop() {
...
// Drehzahl auslesen
int pulseFrequency = digitalRead(SPEED_PIN);
int motorSpeed = (pulseFrequency * 60) / MOTOR_POLE_PAIRS; // Drehzahl berechnen unter Berücksichtigung der Polpaare
}

Du musst die Impulse in einem Zeitfenster lesen und dann hochrechnen.

Also z.B.

"letzterZeitpunkt" = millis();
while (("letzterZeitpunkt" + "zeitfenster") > millis())
{
//hier die Impulse zählen
}

Die Breite des Zeitfensters sollte nicht zu groß gewählt werden, da das Programm ja an dieser Stelle verweilt.

Danach kannst du die Motordrehzahl berechnen:

U/"zeitfenster"*60

Dies ist eine Möglichkeit, es gibt sicherlich noch andere!

Gruß Lothar

Vielen Dank für deine Antwort!
Ich habe mal versucht den Code entsprechend abzuändern… wäre es so korrekt?

Code: Alles auswählen

 #include <TM1637Display.h>
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 2 // Pin für den DS18B20-Sensor
#define CLK 3 // Pin CLK des TM1637-Displays
#define DIO 4 // Pin DIO des TM1637-Displays
#define SPEED_PIN 5 // Pin für den SPEED-Ausgang vom Treiber
#define ALARM_PIN 6 // Pin für den ALM-Ausgang vom Treiber
#define MOTOR_POLE_PAIRS 4 // Anzahl der Motorpolpaare
#define TIME_WINDOW 1000 // Zeitfenster in Millisekunden

volatile int pulseCount = 0; // Variable für die Anzahl der Pulsen

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
TM1637Display display(CLK, DIO);

void setup() {
  Serial.begin(9600);
  sensors.begin();
  display.setBrightness(0x0a); // Helligkeit einstellen (0-0x0f)
  pinMode(SPEED_PIN, INPUT_PULLUP);
  pinMode(ALARM_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(SPEED_PIN), countPulses, RISING);
}

void loop() {
  sensors.requestTemperatures(); // Temperatur aktualisieren
  float tempC = sensors.getTempCByIndex(0); // Temperatur in Celsius lesen
  if (tempC != DEVICE_DISCONNECTED_C) { // Überprüfen, ob ein gültiger Wert gelesen wurde
    // Temperatur im Terminal anzeigen
    Serial.print("Temperatur: ");
    Serial.print(tempC);
    Serial.println(" °C");

    // Temperatur auf dem TM1637-Display anzeigen
    int temp = int(tempC); // Temperatur auf ganze Zahl konvertieren
    display.showNumberDec(temp); // Temperatur ohne Dezimalstelle auf dem Display anzeigen
  } else {
    // Fehlerbehandlung, wenn kein gültiger Wert gelesen werden kann
    Serial.println("Fehler beim Lesen der Temperatur");
    display.showNumberDec(8888); // Anzeige auf "8888" setzen, wenn ein Fehler auftritt
  }

  // Warten bis das Zeitfenster abgelaufen ist
  delay(TIME_WINDOW);
  
  // Anzahl der Impulse im Zeitfenster auslesen
  int pulseCountSnapshot = pulseCount;
  pulseCount = 0; // Reset pulse count for the next window

  // Motordrehzahl basierend auf der Anzahl der Impulse und der Dauer des Zeitfensters berechnen
  float motorSpeed = (pulseCountSnapshot * 60.0) / MOTOR_POLE_PAIRS / (TIME_WINDOW / 1000.0); // Drehzahl in U/min

  // Anzeige der Motordrehzahl
  Serial.print("Drehzahl: ");
  Serial.print(motorSpeed);
  Serial.println(" U/min");
}

void countPulses() {
  pulseCount++; // Increment pulse count when a rising edge is detected
}

[PabloNop]

Ich habe mal versucht den Code entsprechend abzuändern… wäre es so korrekt?

Nicht wirklich, denn das Auslesen des Temperatursensors kostet Zeit: sensors.requestTemperatures blockiert, bis die Daten konvertiert sind. Diese Zeit musst Du in der Berechnung der Drehzahl berücksichtigen, sonst wird zu viel angezeigt.

[grotbeck]

Ich habe mal versucht den Code entsprechend abzuändern… wäre es so korrekt?

Nicht wirklich, denn das Auslesen des Temperatursensors kostet Zeit: sensors.requestTemperatures blockiert, bis die Daten konvertiert sind. Diese Zeit musst Du in der Berechnung der Drehzahl berücksichtigen, sonst wird zu viel angezeigt.

Danke für deinen Tipp!

Vielleicht so?

Code: Alles auswählen

#include <TM1637Display.h>
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 2 // Pin für den DS18B20-Sensor
#define CLK 3 // Pin CLK des TM1637-Displays
#define DIO 4 // Pin DIO des TM1637-Displays
#define SPEED_PIN 5 // Pin für den SPEED-Ausgang vom Treiber
#define ALARM_PIN 6 // Pin für den ALM-Ausgang vom Treiber
#define MOTOR_POLE_PAIRS 4 // Anzahl der Motorpolpaare
#define TIME_WINDOW 1000 // Zeitfenster in Millisekunden

volatile int pulseCount = 0; // Variable für die Anzahl der Pulsen

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
TM1637Display display(CLK, DIO);

void setup() {
  Serial.begin(9600);
  sensors.begin();
  display.setBrightness(0x0a); // Helligkeit einstellen (0-0x0f)
  pinMode(SPEED_PIN, INPUT_PULLUP);
  pinMode(ALARM_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(SPEED_PIN), countPulses, RISING);
}

void loop() {
  unsigned long startTime = millis(); // Zeitstempel vor dem Auslesen der Temperatur

  sensors.requestTemperatures(); // Temperatur aktualisieren
  float tempC = sensors.getTempCByIndex(0); // Temperatur in Celsius lesen
  if (tempC != DEVICE_DISCONNECTED_C) { // Überprüfen, ob ein gültiger Wert gelesen wurde
    // Temperatur im Terminal anzeigen
    Serial.print("Temperatur: ");
    Serial.print(tempC);
    Serial.println(" °C");

    // Temperatur auf dem TM1637-Display anzeigen
    int temp = int(tempC); // Temperatur auf ganze Zahl konvertieren
    display.showNumberDec(temp); // Temperatur ohne Dezimalstelle auf dem Display anzeigen
  } else {
    // Fehlerbehandlung, wenn kein gültiger Wert gelesen werden kann
    Serial.println("Fehler beim Lesen der Temperatur");
    display.showNumberDec(8888); // Anzeige auf "8888" setzen, wenn ein Fehler auftritt
  }

  unsigned long endTime = millis(); // Zeitstempel nach dem Auslesen der Temperatur
  unsigned long elapsedTime = endTime - startTime; // Zeit für das Auslesen der Temperatur in Millisekunden

  // Warten bis das Zeitfenster abgelaufen ist
  delay(TIME_WINDOW - elapsedTime);
  
  // Anzahl der Impulse im Zeitfenster auslesen
  int pulseCountSnapshot = pulseCount;
  pulseCount = 0; // Reset pulse count for the next window

  // Motordrehzahl basierend auf der Anzahl der Impulse und der Dauer des Zeitfensters berechnen
  float motorSpeed = (pulseCountSnapshot * 60.0) / MOTOR_POLE_PAIRS / ((TIME_WINDOW - elapsedTime) / 1000.0); // Drehzahl in U/min

  // Anzeige der Motordrehzahl
  Serial.print("Drehzahl: ");
  Serial.print(motorSpeed);
  Serial.println(" U/min");
}

void countPulses() {
  pulseCount++; // Increment pulse count when a rising edge is detected
}

In diesem Sketch verwende ich millis() zum Messen der Zeit, die für das Auslesen der Temperatur benötigt wird. Diese Zeit wird dann von der Gesamtdauer des Zeitfensters abgezogen, um sicherzustellen, dass die Drehzahlberechnung korrekt ist.

[PabloNop]

Wenn Du das Delay auf "TIME_WINDOW - elapsedTime" musst Du für die Upm dennoch durch TIME_WINDOW dividieren (weil ja soviel Zeit vergangen ist).
Ein anderes Problem könnte noch sein, was passiert, wenn die Differenz negativ wird...

[grotbeck]

Wenn Du das Delay auf "TIME_WINDOW - elapsedTime" musst Du für die Upm dennoch durch TIME_WINDOW dividieren (weil ja soviel Zeit vergangen ist).
Ein anderes Problem könnte noch sein, was passiert, wenn die Differenz negativ wird...

Das ist ein guter Punkt!

Code: Alles auswählen

#include <TM1637Display.h>
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 2 // Pin für den DS18B20-Sensor
#define CLK 3 // Pin CLK des TM1637-Displays
#define DIO 4 // Pin DIO des TM1637-Displays
#define SPEED_PIN 5 // Pin für den SPEED-Ausgang vom Treiber
#define ALARM_PIN 6 // Pin für den ALM-Ausgang vom Treiber
#define MOTOR_POLE_PAIRS 4 // Anzahl der Motorpolpaare
#define TIME_WINDOW 1000 // Zeitfenster in Millisekunden

volatile int pulseCount = 0; // Variable für die Anzahl der Pulsen

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
TM1637Display display(CLK, DIO);

void setup() {
  Serial.begin(9600);
  sensors.begin();
  display.setBrightness(0x0a); // Helligkeit einstellen (0-0x0f)
  pinMode(SPEED_PIN, INPUT_PULLUP);
  pinMode(ALARM_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(SPEED_PIN), countPulses, RISING);
}

void loop() {
  unsigned long startTime = millis(); // Zeitstempel vor dem Auslesen der Temperatur

  sensors.requestTemperatures(); // Temperatur aktualisieren
  float tempC = sensors.getTempCByIndex(0); // Temperatur in Celsius lesen
  if (tempC != DEVICE_DISCONNECTED_C) { // Überprüfen, ob ein gültiger Wert gelesen wurde
    // Temperatur im Terminal anzeigen
    Serial.print("Temperatur: ");
    Serial.print(tempC);
    Serial.println(" °C");

    // Temperatur auf dem TM1637-Display anzeigen
    int temp = int(tempC); // Temperatur auf ganze Zahl konvertieren
    display.showNumberDec(temp); // Temperatur ohne Dezimalstelle auf dem Display anzeigen
  } else {
    // Fehlerbehandlung, wenn kein gültiger Wert gelesen werden kann
    Serial.println("Fehler beim Lesen der Temperatur");
    display.showNumberDec(8888); // Anzeige auf "8888" setzen, wenn ein Fehler auftritt
  }

  unsigned long endTime = millis(); // Zeitstempel nach dem Auslesen der Temperatur
  unsigned long elapsedTime = endTime - startTime; // Zeit für das Auslesen der Temperatur in Millisekunden

  // Warten bis das Zeitfenster abgelaufen ist
  long remainingTime = max(TIME_WINDOW - elapsedTime, 0); // Sicherstellen, dass die verbleibende Zeit nicht negativ wird
  delay(remainingTime);
  
  // Anzahl der Impulse im Zeitfenster auslesen
  int pulseCountSnapshot = pulseCount;
  pulseCount = 0; // Reset pulse count for the next window

  // Motordrehzahl basierend auf der Anzahl der Impulse und der Dauer des Zeitfensters berechnen
  float motorSpeed = (pulseCountSnapshot * 60.0) / MOTOR_POLE_PAIRS / (TIME_WINDOW / 1000.0); // Drehzahl in U/min

  // Anzeige der Motordrehzahl
  Serial.print("Drehzahl: ");
  Serial.print(motorSpeed);
  Serial.println(" U/min");
}

void countPulses() {
  pulseCount++; // Increment pulse count when a rising edge is detected
}

In diesem Sketch wird die verbleibende Zeit remainingTime berechnet, indem die Differenz zwischen TIME_WINDOW und elapsedTime ermittelt wird. Diese Zeit wird dann verwendet, um das Delay zu steuern, und sie wird auf 0 gesetzt, wenn sie negativ wird. Ich hoffe, das behebt das Problem

[Bitter]

Mach es doch nicht so kompliziert:

Code: Alles auswählen

void setup() {
  Serial.begin(9600);
  pinMode(SPEED_PIN, INPUT_PULLUP);
  pinMode(ALARM_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(SPEED_PIN), countPulses, RISING);
  startTime = millis();
}

void loop() {
  ......
  if (startTime + TIME_WINDOW >= millis()) 
  {
    unsigned long elapsedTime = millis()-startTime;
    float F = pulseCount/elapsedTime;
    float motorSpeed = F / MOTOR_POLE_PAIRS * 60; // Drehzahl in U/min
    pulseCount = 0; // Reset pulse count for the next window
    startTime = millis();
      // Anzeige der Motordrehzahl
    Serial.print("Drehzahl: ");
    Serial.print(motorSpeed);
    Serial.println(" U/min");
  }
}

void countPulses() {
  pulseCount++; // Increment pulse count when a rising edge is detected
}

Mit der Größe des Zeitfensters solltest du experimentieren.

Gruß Lothar

[grotbeck]

Elegant gelöst! Vielen Dank!

Trotzdem muss ich leider sagen, dass im Seriellen Monitor weiterhin nur 0,00 U/min angezeigt wird, egal wie schnell der Motor dreht das ist echt zum verzweifeln

[Bitter]

Setze doch an geeigneter Stelle mal Ausgabe im Seriellen-Monitor.

Code: Alles auswählen

void loop() {
  Serial.println(pulseCount);
  if (startTime + TIME_WINDOW >= millis()) 

Wird der Wert von pulseCount überhaupt inkrementiert?

Falls du ein Oszilloskop besitzen solltest, wie sieht denn das Signal an SPEED aus?

Du kannst natürlich auch einen einfachen Sketch verwenden und in Abhängigkeit vom Signal am Digitalpin an einem Ausgangspin eine LED zur Anzeige bringen. Dann siehst du jedenfalls, ob das Speedsignal OK ist.

Gruß Lothar

[grotbeck]

Gute Idee,
ich denke das Hinzufügen einer zusätzlichen Ausgabe in der countPulses()-Funktion, um sicherzustellen, dass sie aufgerufen wird, wäre eine Möglichkeit. Hier ist der überarbeitete Sketch mit dieser Änderung:

Code: Alles auswählen

#include <TM1637Display.h>
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 2 // Pin für den DS18B20-Sensor
#define CLK 3 // Pin CLK des TM1637-Displays
#define DIO 4 // Pin DIO des TM1637-Displays
#define SPEED_PIN 5 // Pin für den SPEED-Ausgang vom Treiber
#define ALARM_PIN 6 // Pin für den ALM-Ausgang vom Treiber
#define MOTOR_POLE_PAIRS 4 // Anzahl der Motorpolpaare
#define TIME_WINDOW 1000 // Zeitfenster in Millisekunden

volatile int pulseCount = 0; // Variable für die Anzahl der Pulsen
unsigned long startTime = 0; // Zeitstempel für den Start des Zeitfensters

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
TM1637Display display(CLK, DIO);

void setup() {
  Serial.begin(9600);
  sensors.begin();
  display.setBrightness(0x0a); // Helligkeit einstellen (0-0x0f)
  pinMode(SPEED_PIN, INPUT_PULLUP);
  pinMode(ALARM_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(SPEED_PIN), countPulses, RISING);
  startTime = millis(); // Initialisierung des Zeitstempels für den Start
}

void loop() {
  // Auslesen der Temperatur und Anzeige
  sensors.requestTemperatures(); // Temperatur aktualisieren
  float tempC = sensors.getTempCByIndex(0); // Temperatur in Celsius lesen
  if (tempC != DEVICE_DISCONNECTED_C) { // Überprüfen, ob ein gültiger Wert gelesen wurde
    Serial.print("Temperatur: ");
    Serial.print(tempC);
    Serial.println(" °C");
    int temp = int(tempC); // Temperatur auf ganze Zahl konvertieren
    display.showNumberDec(temp); // Temperatur ohne Dezimalstelle auf dem Display anzeigen
  } else {
    Serial.println("Fehler beim Lesen der Temperatur");
    display.showNumberDec(8888); // Anzeige auf "8888" setzen, wenn ein Fehler auftritt
  }

  // Ausgabe der Impulsanzahl zur Überprüfung
  Serial.println(pulseCount);

  // Berechnung und Anzeige der Motordrehzahl
  if (startTime + TIME_WINDOW >= millis()) {
    unsigned long elapsedTime = millis() - startTime; // Verstrichene Zeit seit dem Start des Zeitfensters
    float F = pulseCount / elapsedTime; // Pulse pro Millisekunde berechnen
    float motorSpeed = F / MOTOR_POLE_PAIRS * 60; // Drehzahl in U/min berechnen
    pulseCount = 0; // Reset pulse count for the next window
    startTime = millis(); // Aktualisiere den Startzeitpunkt für das nächste Zeitfenster
    Serial.print("Drehzahl: ");
    Serial.print(motorSpeed);
    Serial.println(" U/min");
  }
}

void countPulses() {
  pulseCount++; // Increment pulse count when a rising edge is detected
  Serial.println("Puls erkannt!"); // Ausgabe zur Überprüfung
}

Der serielle Monitor zeigt trotzdem nur folgendes:
Temperatur: 22.31 °C
0
Drehzahl: 0.00 U/min
Temperatur: 22.33 °C
0
Drehzahl: 0.00 U/min

[Bitter]

Keine Ausgabe in die ISR setzen! Zählt denn pulseCount überhaupt hoch?

[grotbeck]

Sorry, ich bin etwas überfordert

So?

Code: Alles auswählen

#include <TM1637Display.h>
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 2 // Pin für den DS18B20-Sensor
#define CLK 3 // Pin CLK des TM1637-Displays
#define DIO 4 // Pin DIO des TM1637-Displays
#define SPEED_PIN 5 // Pin für den SPEED-Ausgang vom Treiber
#define ALARM_PIN 6 // Pin für den ALM-Ausgang vom Treiber
#define MOTOR_POLE_PAIRS 4 // Anzahl der Motorpolpaare
#define TIME_WINDOW 1000 // Zeitfenster in Millisekunden

volatile int pulseCount = 0; // Variable für die Anzahl der Pulsen
unsigned long startTime = 0; // Zeitstempel für den Start des Zeitfensters

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
TM1637Display display(CLK, DIO);

void setup() {
  Serial.begin(9600);
  sensors.begin();
  display.setBrightness(0x0a); // Helligkeit einstellen (0-0x0f)
  pinMode(SPEED_PIN, INPUT_PULLUP);
  pinMode(ALARM_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(SPEED_PIN), countPulses, RISING);
  startTime = millis(); // Initialisierung des Zeitstempels für den Start
}

void loop() {
  // Auslesen der Temperatur und Anzeige
  sensors.requestTemperatures(); // Temperatur aktualisieren
  float tempC = sensors.getTempCByIndex(0); // Temperatur in Celsius lesen
  if (tempC != DEVICE_DISCONNECTED_C) { // Überprüfen, ob ein gültiger Wert gelesen wurde
    Serial.print("Temperatur: ");
    Serial.print(tempC);
    Serial.println(" °C");
    int temp = int(tempC); // Temperatur auf ganze Zahl konvertieren
    display.showNumberDec(temp); // Temperatur ohne Dezimalstelle auf dem Display anzeigen
  } else {
    Serial.println("Fehler beim Lesen der Temperatur");
    display.showNumberDec(8888); // Anzeige auf "8888" setzen, wenn ein Fehler auftritt
  }

  // Berechnung und Anzeige der Motordrehzahl
  if (startTime + TIME_WINDOW >= millis()) {
    unsigned long elapsedTime = millis() - startTime; // Verstrichene Zeit seit dem Start des Zeitfensters
    float F = pulseCount / elapsedTime; // Pulse pro Millisekunde berechnen
    float motorSpeed = F / MOTOR_POLE_PAIRS * 60; // Drehzahl in U/min berechnen
    pulseCount = 0; // Reset pulse count for the next window
    startTime = millis(); // Aktualisiere den Startzeitpunkt für das nächste Zeitfenster
    Serial.print("Drehzahl: ");
    Serial.print(motorSpeed);
    Serial.println(" U/min");
  }
}

void countPulses() {
  pulseCount++; // Increment pulse count when a rising edge is detected
}

[Bitter]

Gerade gesehen, du benutzt PIN 5 als Interruptpin, das funktioniert beim UNO nicht. Du musst PIN 2 oder 3 benutzen!

[grotbeck]

Das erklärt eventuell meine Problematik! Das wusste ich nicht! Ich werde es später umstecken (ist leider schon verlötet) und mich dann noch mal melden! Vielen Dank schon mal!

[grotbeck]

Ich habe jetzt das SPEED Kabel an den PIN 2 gesteckt und dafür den Temperatursensor an PIN 7 und den Code entsprechend geändert.

Leider immer noch 0,00 U/min im seriellen Monitor

Code: Alles auswählen

#include <TM1637Display.h>
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 7 // Pin für den DS18B20-Sensor
#define CLK 3 // Pin CLK des TM1637-Displays
#define DIO 4 // Pin DIO des TM1637-Displays
#define SPEED_PIN 2 // Pin für den SPEED-Ausgang vom Treiber (Interrupt-Pin)
#define ALARM_PIN 6 // Pin für den ALM-Ausgang vom Treiber
#define MOTOR_POLE_PAIRS 4 // Anzahl der Motorpolpaare
#define TIME_WINDOW 1000 // Zeitfenster in Millisekunden

volatile int pulseCount = 0; // Variable für die Anzahl der Pulsen
unsigned long startTime = 0; // Zeitstempel für den Start des Zeitfensters

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
TM1637Display display(CLK, DIO);

void setup() {
  Serial.begin(9600);
  sensors.begin();
  display.setBrightness(0x0a); // Helligkeit einstellen (0-0x0f)
  pinMode(SPEED_PIN, INPUT_PULLUP);
  pinMode(ALARM_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(SPEED_PIN), countPulses, RISING);
  startTime = millis(); // Initialisierung des Zeitstempels für den Start
}

void loop() {
  // Auslesen der Temperatur und Anzeige
  sensors.requestTemperatures(); // Temperatur aktualisieren
  float tempC = sensors.getTempCByIndex(0); // Temperatur in Celsius lesen
  if (tempC != DEVICE_DISCONNECTED_C) { // Überprüfen, ob ein gültiger Wert gelesen wurde
    Serial.print("Temperatur: ");
    Serial.print(tempC);
    Serial.println(" °C");
    int temp = int(tempC); // Temperatur auf ganze Zahl konvertieren
    display.showNumberDec(temp); // Temperatur ohne Dezimalstelle auf dem Display anzeigen
  } else {
    Serial.println("Fehler beim Lesen der Temperatur");
    display.showNumberDec(8888); // Anzeige auf "8888" setzen, wenn ein Fehler auftritt
  }

  // Berechnung und Anzeige der Motordrehzahl
  if (startTime + TIME_WINDOW >= millis()) {
    unsigned long elapsedTime = millis() - startTime; // Verstrichene Zeit seit dem Start des Zeitfensters
    float F = pulseCount / elapsedTime; // Pulse pro Millisekunde berechnen
    float motorSpeed = F / MOTOR_POLE_PAIRS * 60; // Drehzahl in U/min berechnen
    pulseCount = 0; // Reset pulse count for the next window
    startTime = millis(); // Aktualisiere den Startzeitpunkt für das nächste Zeitfenster
    Serial.print("Drehzahl: ");
    Serial.print(motorSpeed);
    Serial.println(" U/min");
  }
}

void countPulses() {
  pulseCount++; // Increment pulse count when a rising edge is detected
}

Setze doch an geeigneter Stelle mal Ausgabe im Seriellen-Monitor.

Code: Alles auswählen

void loop() {
  Serial.println(pulseCount);
  if (startTime + TIME_WINDOW >= millis()) 

Wird der Wert von pulseCount überhaupt inkrementiert?

Falls du ein Oszilloskop besitzen solltest, wie sieht denn das Signal an SPEED aus?

Du kannst natürlich auch einen einfachen Sketch verwenden und in Abhängigkeit vom Signal am Digitalpin an einem Ausgangspin eine LED zur Anzeige bringen. Dann siehst du jedenfalls, ob das Speedsignal OK ist.

Gruß Lothar

Leider besitze ich kein Oszilloskop :-(

[Bitter]

Da ist noch ein Fehler im Code. Du musst mit 60000 ms multiplizieren, statt mit 60 s. Hatte ich übersehen.
Unabhängig davon müsstest du jetzt eine Ausgabe > 0 bei "Serial.println(pulseCount);" bekommen. Vergrößere doch einfach mal das Zeitfenster auf 60 s.

Gruß Lothar

[Bitter]

Um überhaupt zu sehen, ob die Signale am Speed-Ausgang OK sind, spiele doch einmal folgenden Sketch auf:

Code: Alles auswählen

const byte ledPin = 5;  //oder ein anderer
const byte SPEED_PIN = 2;
volatile byte state = LOW;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(SPEED_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(SPEED_PIN), led_ein_aus, CHANGE);
}

void loop() {
  digitalWrite(ledPin, state);
}

void led_ein_aus() {
  state = !state;
}

Nimm irgendeine LED und einen Widerstand um die 200 Ohm, die LED sollte blinken!

Gruß Lothar

[grotbeck]

Es funktioniert! Ich bekomme nun eine Drehzahl angezeigt! Danke für die tolle Hilfe!
Ich habe das Zeitfenster nun auf 5 Sekunde stehen.

Ich meine, die Drehzahl wird zu hoch ausgegeben (gefühlt ungefähr doppelt so hoch als die tatsächliche Drehzahl). Kann das an der angenommenen Polzahl liegen?
#define MOTOR_POLE_PAIRS 4 // Anzahl der Motorpolpaare
Das ist tatsächlich nur ein angenommener Wert, weil ich leider kein Datenblatt zur Hand habe.

[Bitter]

Bringt Google dich da nicht weiter, sollte doch was zu finden sein! Eine Anfrage an den Hersteller bringt oft auch eine Lösung, oder, du probierst es einfach aus! Wie langsam kann der Motor denn drehen, um ggf. die tatsächliche Umdrehungszahl herauszufinden?

Gruß Lothar