volvodani:
Deswegen will ich einen Interrupt haben der erst nach 10.000 >Impulsen an dem einen Eingang eine ISR startet.
Was machst Du eigentlich, wenn die Maschine mal nicht mit 500 UPM dreht, sondern nur mit 10 UPM?
Ist es wirklich optimal, die Aktualisierungshäufigkeit der Anzeige von der Drehzahl der Walzen abhängig zu machen?
Ich würde es anders machen, die Anzeige immer im gleichmäßigen Takt aktualisieren.
Und habe dazu mal was vorbereitet.
Da ich keine Maschine und keine Walzen und keine Signalgeber habe, habe ich einen Simulator-Sketch gemacht, der gleichzeitig Impulsgenerator ist und pro Minute 500000 Impulse pro "Walze" erzeugt (und damit die Maschine mit Master- und Slavewalze simuliert) und auch das Messen der Impulse und feststellen der Geschwindigkeitsdifferenz übernimmt.
Verwendet habe ich einen UNO, der externe Interrupts an Pin-2 und Pin-3 erkennen kann.
#define Walze1Signal 2
#define Walze2Signal 3
Mein "Impulsgenerator" erzeugt Impulse an Pin-4 und Pin-5
// Pins für den simulierten Signalgeber
#define Walze1Geber 4
#define Walze2Geber 5
Für den Sketch zur Simulation wird also direkt Pin-4 ("Impuls von der Master-Walze") mit Pin-2 verbunden und Pin-5 ("Impuls von der Slave-Walze") mit Pin-3. Es ist natürlich keine optimale Simulation, da die Impulse von der loop aus mit einer Funktion generiert werden, aber besser als gar nichts. Wenn Du hast, kannst Du natürlich auch Rechteck-Signalgeneratoren anschließen. Oder Deine Maschine.
Ein paar Tricks mußte ich einbauen, damit es von der Geschwindigkeit her ausreicht, mit dem Sketch sowohl die Signale ausreichend schnell zu erzeugen als auch auszuwerten. Der Haupttrick in der loop ist, die Auswertung alle 1024 Millisekunden zu machen, weil sich sehr schnell ermitteln läßt, ob der millis-Zähler einen neuen durch eine Zweierpotenz teilbaren Wert erreicht hat. Die Drehzahl pro Minute ergibt sich dadurch nicht über eine Multiplikation mit 60 wie es bei einer Aktualisierung im Sekundentakt der Fall wäre, sondern über eine Multiplikation mit 58.59375, da 1,024 s * 58.59375 = 60 Sekunden ergibt.
In meinem Sketch wird die Anzeige nicht "nach 10000 Impulsen", sondern immer nach 1,024 Sekunden auf den aktuellen Stand gebracht.
Wie man sieht, produziert mein Sketch kleine Drehzahlunterschiede, die sich daraus ergeben, dass mal ein Impuls mehr oder weniger gezählt wird.
Für eine optimale Darstellung würde ich empfehlen, den Anzeigewert exponentiell zu glätten. Parameter für die Glättung nach Bedarf.
Der Sketch ist so ja erstmal sehr experimentell.
Aber ausbaufähig. 
/* Walzendrehzahlen einer Maschine messen,
die Maschine habe eine Masterwalze und eine Slavewalze,
die je 1000 Impulse pro Umdrehung abgeben und mit ca. 500 Umdrehungen pro Minute laufen
ermittelt werden soll der Drehzahlunterschied in %
Der Sketch erzeugt simulierte Walzenimpulse an Pin-4 und -5.
Verkabelung zur Simulation:
- eine Drahtbrücke zwischen Pin-2 und Pin-4
- eine Drahtbrücke zwischen Pin-3 und Pin-5
Verkabelung im Betrieb mit Maschine:
- Impuls der Masterwalze an Pin-2
- Impuls der Slavewalze an Pin-3
Zielplattform: Arduino UNO mit Interrupt-0 an Pin2 und Interrupt-1 an Pin-3
*/
// Eingangspins für das Walzensignal
#define Walze1Signal 2
#define Walze2Signal 3
// Pins für den simulierten Signalgeber
#define Walze1Geber 4
#define Walze2Geber 5
// Zähler für die Impulse volatile deklarieren, da in Interrupt verwendet
volatile long w1counter;
volatile long w2counter;
void setup()
{
Serial.begin(9600);
pinMode(Walze1Signal,INPUT);
pinMode(Walze2Signal,INPUT);
pinMode(Walze1Geber,OUTPUT);
pinMode(Walze2Geber,OUTPUT);
attachInterrupt(0,Walze1ISR,RISING);
attachInterrupt(1,Walze2ISR,RISING);
}
void Walze1ISR()
// Interrupt-Serviceroutine für die Master-Walze
{
w1counter++;
}
void Walze2ISR()
// Interrupt-Serviceroutine für die Slave-Walze
{
w2counter++;
}
// Drehzahl festlegen, "Nanosekunden zwischen zwei Impulsen"
// 60000 Nanosekunden entspricht 500 U/min bei 1000 Impulsen pro Umdrehung
// hier für die Simulation vorgegeben: kleiner Drehzahlunterschied
#define w1mus 60002L
// kleinere Zahlen stehen für höhere Drehzahlen, größere Zahlen für nierigere Drehzahlen
#define w2mus 60004L
void impulsGenerator()
{
static long nano1rest, nano2rest, alteMicros;
unsigned long neueMicros,nanodiff;
neueMicros=micros();
nanodiff=1000*(neueMicros-alteMicros);
alteMicros=neueMicros;
nano1rest+=nanodiff;
nano2rest+=nanodiff;
if (nano1rest>w1mus)
{
digitalWrite(Walze1Geber,!digitalRead(Walze1Geber));
nano1rest-=w1mus;
}
if (nano2rest>w2mus)
{
digitalWrite(Walze2Geber,!digitalRead(Walze2Geber));
nano2rest-=w2mus;
}
}
long alteSekunde, sekunde;
void loop()
{
impulsGenerator(); // Simulation der Walzenimpulse durch die Funktion "impulsGenerator()"
sekunde=millis()/1024; // Aus Gründen der schnelleren Berechnung 1024 Millisekunden
if (sekunde!=alteSekunde) // Ca. einmal pro Sekunde (alle 1024ms) die Anzeige aktualisieren
{
alteSekunde=sekunde;
// Zuerst bei deaktivierten Interrupts die volatile-Variablen umkopieren und zurücksetzen
noInterrupts(); // Interrupts sperren
long W1impulse=w1counter;
w1counter=0;
long W2impulse=w2counter;
w2counter=0;
interrupts(); // Interrupts zulassen
// Drehzahl pro Minute ermitteln bei 60 Sek/Min und 1000 Impulse/Umdrehung
// Eine Minute besteht aus 58.59375 * 1024 ms
float Drehzahl1=W1impulse*58.59375/1000.0;
float Drehzahl2=W2impulse*58.59375/1000.0;
// Drehzahlen und Impulse der letzten Sekunde ausgeben
Serial.print("Master\t");Serial.print(Drehzahl1,3);Serial.print(" UPM\t");
Serial.print(W1impulse);
Serial.print("\tSlave\t");Serial.print(Drehzahl2,3);Serial.print(" UPM\t");
Serial.print(W2impulse);
Serial.print("\tDiff: ");Serial.print((Drehzahl2/Drehzahl1-1)*100);
Serial.println(" %");
}
}
P.S.: Wennn Du doch lieber die Logik mit der Anzeigeaktualisierung nach 10000 Impulsen hättest statt nach Zeitablauf, ist das natürlich leicht einzubauen mit einer anderen if-Abfrage in der Loop-Funktion, dann schreibst Du einfach:
if (w1counter>=10000) ...
und führst entsprechend etwas andere Berechnungen durch.
