Hallo Zusammen,
ich knabber seit einer ganzen Weile an folgendem Problem:
Für eine Art Hebebühne benötige ich folgenden Ablauf:
Wenn ich einen Button auf meinem Steckbrett drücke soll der Linearmotor ausfahren (einfaches 5V Steuersignal) und der Arduino soll anfangen Impulse pro Sekunde zu messen.
In dem Motor sind hierfür Hall-Sensoren verbaut, welche mir Impulse relativ zum Abstand ausgeben.
Wenn die Impulse pro Sekunde den Wert 0 erreichen, ist mein Linearmotor entweder ganz ausgefahren bzw. ganz eingefahren und das Steuersignal kann auf 0V gehen.
Jetzt soll ca. 20 Sekunden gewartet werden, bevor der Motor wieder einfährt (wieder 5V Steuersignal). Wieder die Impulse der Hallsensoren pro Sekunde messen und wenn der Wert 0 erreicht, dass Steuersignal auf 0V.
Das ganze soll in einer Endlosschleife stattfinden, bis ich den Button auf meinem Steckbrett drücke.
Dieser soll als eine Art An-Aus-Switch dienen.
Code zum Messen der Impulse:
int pin = 2;
volatile unsigned int pulse;
constintpulses_per_litre = 450;
void setup()
{
Serial.begin(9600);
pinMode(pin, INPUT);
attachInterrupt(0, count_pulse, RISING);
}
void loop()
{
pulse=0;
interrupts();
delay(1000);
noInterrupts();
Serial.print("Pulses per second: ");
Serial.println(pulse);
}
voidcount_pulse()
{
pulse++;
}
Mein Problem ist aktuell, dass das Messen der Impulse pro Sekunde aktuell über einen Interrupt Befehl läuft und ich daher nicht wirklich mit meinem Button arbeiten kann (debounce usw.)
Habe mich jetzt bereits ein bisschen schlau gemacht und festgestellt, dass während dem interrupt keine delay Befehle ausgeführt werden können.
Ich muss die Befehlskette mit Hilfe der Impulse ausführen und kann leider nicht einfach eine feste Zeit zum abstellen des Motors einstellen, da dieser je nach Last unterschiedlich viel Zeit benötigt.
Gesamter Code bisher:
int pin = 2;
volatile unsigned int pulse;
int Hoch = 1;
const int rausPin = 12;
const int reinPin = 13;
int buttonPin = 3; // the number of the input pin
int LEDPin = 4; // the number of the output pin
int state = HIGH; // the current state of the output pin
int reading; // the current reading from the input pin
int previous = LOW; // the previous reading from the input pin
// the follow variables are long's because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long time = 0; // the last time the output pin was toggled
long debounce = 200; // the debounce time, increase if the output flickers
void setup()
{
Serial.begin(9600);
pinMode(buttonPin, INPUT);
pinMode(LEDPin, OUTPUT);
attachInterrupt(0, count_pulse, RISING);
}
void loop()
{
reading = digitalRead(buttonPin);
// if the input just went from LOW and HIGH and we've waited long enough
// to ignore any noise on the circuit, toggle the output pin and remember
// the time
if (reading == HIGH && previous == LOW && millis() - time > debounce) {
if (state == HIGH)
state = LOW;
else
state = HIGH;
time = millis();
}
digitalWrite(LEDPin, state);
previous = reading;
if (state == HIGH)
{
if (Hoch == 1)
{
Serial.println("Hoch Start");
digitalWrite(rausPin, HIGH);
delay(200);
pulse=0;
noInterrupts();
delay(500);
interrupts();
if (pulse == 0)
{
Serial.println("Fertig Hoch!");
delay(200);
digitalWrite(rausPin, LOW);
delay(20000);
Hoch = 0;
}
}
else if (Hoch == 0)
{
Serial.println("Runter Start");
digitalWrite(reinPin, HIGH);
delay(200);
pulse=0;
noInterrupts();
delay(500);
interrupts();
if (pulse == 0)
{
Serial.println("Fertig Runter!");
delay(200);
digitalWrite(reinPin, LOW);
delay(20000);
Hoch = 1;
}
}
}
}
void count_pulse()
{
pulse++;
}
Würde mich über eure Hilfe, Ideen und Anregungen sehr freuen.
Ich verwende auch gerne eine Lösung ohne Interrupt 
Tausend Dank
Grüße
Smoerebrot
[edit]
Evtl. sollte ich mein Problem noch ein bisschen besser beschreiben.
Ich kann die einzelnen Impulse ohne Interrupt mit Hilfe folgenden Codes zählen:
const int pulsePin = 2; // the number of the pulse pin
boolean pulseState, oldpulseState;
unsigned long anzeigeMillis, aktMillis;
const int anzeigeZeit = 100;
void setup() {
pinMode(pulsePin, INPUT_PULLUP);
Serial.begin(9600);
pulseState = digitalRead(pulsePin);
oldpulseState = pulseState;
}
void loop() {
static int Puls;
aktMillis = millis();
pulseState = digitalRead(pulsePin);
if ( pulseState && !oldpulseState ) { // positive Flanke erkannt
Puls++;
}
oldpulseState = pulseState;
if (aktMillis - anzeigeMillis >= anzeigeZeit) {
anzeigeMillis = aktMillis;
Serial.print("Puls: ");
Serial.println(Puls);
}
}
Dabei kommen für einen einfachen Weg (--> Raus bzw. Reinfahren) immer zwischen 156 und 157 Impulse zustande.
Das wäre mein alternativer Weg, immer über die Impulsanzahl zu gehen.
Das Problem hier ist aber, dass wenn ein Impuls zu wenig geliefert wird mein ganzer Code "hängen" bleibt...
