Blinken oder Dauer ein erkennen

[Fohnbit]

Hallo,

wie könnte ich am besten erkennen, ob ein boolscher Wert blinkt oder dauer ein/aus ist.

Über eine Methode wird mir der boolsche Wert "Input1" ein und aus geschaltet.
Wenn "Input1" mind. 2 Sekunden ein ist, dann ist ein Dauer ein.
Wenn "Input1" nur 1,5 Sekunden ein ist und dann abschaltet und danach wieder einschaltet ist es ein Blinken
Wenn "Input1" mind 2 Sekunden aus ist, dann ist es Dauer aus.

Wie soll ich das am besten abbilden?

Danke!

 

[RalleYTN]

Am besten erstellst du einen neuen Thread mit einer Schleife, wo immer der aktuelle Wert von input1 abgefragt wird.

 

[Soloeco]

Nur für mein Verständnis:
Dann muss man doch in der Schleife eine if Abfrage erstellen für jeweils einen der drei Fälle und dann ein return ausgeben oder?

 

[Fohnbit]

Nun, ich muss ja die zeit messen, um zu erkennen, ob kurze oder lange Impule anliegen.
Scheinbar so klappt das mal:
value ist der Status des Blinkers.
Es gibt 2 Kanäle, habe ich vorhin nicht beschrieben

boolean blink1, blink2;
   private ScheduledFuture<?> ein1, aus1, ein2, aus2;
   private ScheduledExecutorService executor;
....
  executor = Executors.newSingleThreadScheduledExecutor();
...

if (value) {
            // Kanal 2 sofort abschalten wenn Kanal 1 einschaltet
            if (aus2 != null) {
                aus2.cancel(true);
                aus2 = null;
            }

            if (ein2 != null) {
                ein2.cancel(true);
                ein2 = null;
            }
            if (getOutputEingang2blinkt()) {
                updateOutputEingang2blinkt(false);
            }
            if (getOutputEingang2ein()) {
                updateOutputEingang2ein(false);
            }

            if (blink1) {
                // Blinken detektiert
                if (!getOutputEingang1blinkt()) {
                    updateOutputEingang1blinkt(true);
                }
                if (getOutputEingang1ein()) {
                    updateOutputEingang1ein(false);
                }

                blink1 = false;
            }
            // Dauer aus abschalten
            if (aus1 != null) {
                aus1.cancel(true);
                aus1 = null;
            }

            // Dauer ein starten
            ein1 = executor.schedule(new Runnable() {
                public void run() {
                    // System.out.println("Dauer ein bei Eingang 1 erkannt");
                    if (getOutputEingang1blinkt()) {
                        updateOutputEingang1blinkt(false);
                    }
                    if (!getOutputEingang1ein()) {
                        updateOutputEingang1ein(true);
                    }

                }
            }, getPropertyEinzeitblinker1() * 3, TimeUnit.MILLISECONDS);

        } else {

            // Dauer aus abschalten
            if (ein1 != null) {
                // Dauer ein läuft noch
                if (!ein1.isDone()) {
                    // System.out.println("Dauer ein läuft noch");
                    // Blinken wird vermutet
                    blink1 = true;
                }

                ein1.cancel(true);
                ein1 = null;
            }

            // Dauer aus starten wenn nach 3facher Zykluszeit kein EIN empfangen
            // wird
            aus1 = executor.schedule(new Runnable() {
                public void run() {
                    blink1 = false;
                    // System.out.println("Dauer AUS bei Eingang 1 erkannt");
                    if (getOutputEingang1blinkt()) {
                        updateOutputEingang1blinkt(false);
                    }
                    if (getOutputEingang1ein()) {
                        updateOutputEingang1ein(false);
                    }
                }
            }, getPropertyEinzeitblinker1() * 3, TimeUnit.MILLISECONDS);

        }

 

[Tobse]

Wieso denn um alles in der Welt ein neuer Thread? Wenn der Wert nur über die Methode gesetzt werden kann, bau doch den code einfach in die Methode:

Zusätzlich zum wert selber speicherst du dir noch den Zeitpunkt der letzten Änderung. Wenn jetzt abgefragt wird, welchen Status der Wert hat (Dauer Ein/Aus oder blinkened) musst nur nur prüfen, ob der Zeitpunkt der letzten Änderung weniger wie 2 Sekunden zurück liegt.

import java.util.Date;

class SomeClass
{
    private boolean value = false;
    private Date valueLastChange = new Date();

    public void setValue(boolean v)
    {
        if (v != value)
        {
            value = v;
            valueLastChange = new Date();
        }
    }
   
    /**
     * Returns true if value is blinking, false if its value was constant for more than 2 seconds.
     */
    public boolean isValueBlinking()
    {
        return (new Date().getTime()) - valueLastChange.getTime() >= 2000;
    }
}

 

[Fohnbit]

Interessante Idee, jedoch muss ich ja das Melden von Dauer ein/aus Verzögern, da ich beim Signal ein noch nicht weiß, ob es blinkt.

Außerdem kann es passieren, das es blinkt, aber dann auf Dauer ein übergeht.
Die Methode würde nicht mehr getriggert werden.

Also muss ich zuerst annehmen das es ein Dauer ein/aus ist ... diesen in einen Timer legen, der 3 Sekunden verzögert ausgegeben wird.
Falls es doch ein Blinken ist, muss ich diese Timer wieder canceln und Blinken melden, oder?

 

[Fohnbit]

So würde es klappen:
a. Es wird die 3-fache Blinkfrequenz gewartet, ob ein Dauer ein/aus gemeldet wird
b. Es werden 2 Blinkzyklen benötigt, um das Blinken zu melden. Es könnte ja sein das einmal kurz ein/aus geschaltet wird. Dann würder er blinken und danach den Dauer ein/aus melden

    private boolean value = false;
    private Date valueLastChange = new Date();
    private int blinkCounter = 0;

    public void setValue(boolean v) {
        if (v != value) {
            value = v;
            valueLastChange = new Date();
        }
    }

    /**
     * Returns true if value is blinking, false if its value was constant for
     * more than 2 seconds.
     */
    public boolean isValueBlinking() {
        return (new Date().getTime()) - valueLastChange.getTime() >= getPropertyEinzeitblinker1();
    }

    @Override
    public void onEingang1(boolean value) {
        if (value) {
            // Austimer abbrechen
            if (aus1 != null) {
                aus1.cancel(true);
                aus1 = null;
            }

            // Dauer ein Timer starten
            ein1 = executor.schedule(new Runnable() {
                public void run() {
                    blinkCounter = 0;
                    if (getOutputEingang1blinkt()) {
                        updateOutputEingang1blinkt(false);
                    }
                    if (!getOutputEingang1ein()) {
                        updateOutputEingang1ein(true);
                    }

                }
            }, getPropertyEinzeitblinker1() * 3, TimeUnit.MILLISECONDS);

        }

        if (!value) {
            // Ein Timer abbrechen
            if (ein1 != null) {
                ein1.cancel(true);
                ein1 = null;
            }

            // Dauer aus Timer starten
            aus1 = executor.schedule(new Runnable() {
                public void run() {
                    blinkCounter = 0;
                    if (getOutputEingang1blinkt()) {
                        updateOutputEingang1blinkt(false);
                    }
                    if (getOutputEingang1ein()) {
                        updateOutputEingang1ein(false);
                    }
                }
            }, getPropertyEinzeitblinker1() * 3, TimeUnit.MILLISECONDS);

        }

        if (!isValueBlinking()) {
            blinkCounter += 1;
if(blinkCounter > 10){
blinkCounter = 2;
}
            if (!getOutputEingang1blinkt() && blinkCounter > 1) {
                updateOutputEingang1blinkt(true);
            }
            if (getOutputEingang1ein() && blinkCounter > 1) {
                updateOutputEingang1ein(false);
            }
        }
        setValue(value);
    }