Hi Leute, hätte da mal eine Frage. Und zwar wollte ich eine eigene Methode zur Flankenerkennung machen, z.B. für eine steigende Flanke.
Soweit so gut, jetzt ist die Frage, kann ich es irgendwie umgehen immer am Anfang meine Loops meinen "rEdgeFlag" auf LOW zu setzen? Dass man die irgendwie temporär machen kann, dass die automatisch nur für einen Durchlauf verändert werden kann.
Gruß Moritz
void rEdge(bool input, bool output) {
bool rEdgeFlag;
if(input == 1 && rEdgeFlag == 0){
output == 1;
}
if(input != rEdgeFlag) {
rEdgeFlag = output;
}
}
Was soll denn diese Funktion machen?
Die kocht doch nur im eigenen Saft und gibt nichts nach außen.
Wenn man etwas output nennt, sollte es auch etwas zurückgeben, was Dein Konstrukt nicht tut.
Schau Dir mal Funktionen mit Rückgabewert an.
Gruß Tommy
fritzko:
... wollte ich eine eigene Methode zur Flankenerkennung machen ...
Wieso das? Mit den Dingen, die ein Arduino „von Haus aus kann“, ist das doch eigentlich überflüssig und damit vergleichbar, dass ich mal einen Brainfuck-Interpreter für die Bash geschrieben habe. Braucht eigentlich keine Sau, kann aber Spaß machen 
Gruß
Gregor
... sehen will ... 
(gerne als Link - nicht, daß ich großartig was mit Brainfuck anfangen könnte - nur von gelesen)
MfG
Haha gibt ja schon gleich Rückmeldungen. Ja hab grade auch gesehen dass das alles nicht so funktioniert 
Immer diese Sache mit Copy - Paste
@Tommy56
Oh ja hab da noch was gesehen was du wohl meintest, wird ja wohl eher nichts mit void
Hallo,
die Funktion hat nichts mit Flankenerkennung zu tun, weil man eher sagen kann das ein "Pegel" (low oder high) an die Funktion übergeben wird. Ich habe die Funktion einmal zusammen gekürzt, damit du selbst siehst was die eigentlich macht und damit eigentlich überflüssig ist. Schritt für Schritt wie in der Schule.
Flankenerkennung in dem Sinne funktioniert so, dass man den alten Zustand mit dem neuen vergleicht und den neuen dann wiederum als alten speichert für den nächsten Vergleich. Rising wäre vorher irgendein Signal hat Low, dann Wechsel auf High Pegel. Falling umgekehrt. Auf den gewünschten Richtungswechsel reagiert man dann.
im Syntax korrigiert mit lokaler Variablen Initialisierung
void rEdge(bool input, bool output)
{
bool rEdgeFlag = 0;
if(input == 1 && rEdgeFlag == 0){
output = 1;
}
if(input != rEdgeFlag) {
rEdgeFlag = output;
}
}
Vergleiche gekürzt
void rEdge(bool input, bool output)
{
bool rEdgeFlag = 0;
if(input == 1){
output = 1;
}
if(input == 1) {
rEdgeFlag = output;
}
}
letzten Vergleich weggekürzt
void rEdge(bool input)
{
bool rEdgeFlag = 0;
if(input == 1){
rEdgeFlag = 1;
}
}
return eingefügt
bool rEdge(bool input)
{
bool rEdgeFlag = 0;
if(input == 1) {
rEdgeFlag = 1;
}
return rEdgeFlag;
}
am Ende bleibt ohne Funktionsrumpf übrig
if(input) {
rEdgeFlag = 1;
}
else {
rEdgeFlag = 0;
}
und das nochmal gekürzt wäre am Ende
rEdgeFlag = input;
lustiges Ergebnis, oder?
postmaster-ino:
... sehen will ... (gerne als Link - nicht, daß ich großartig was mit Brainfuck anfangen könnte - nur von gelesen)
http://test.szaktilla.de/recordmydestop-out-1.ogv und
http://test.szaktilla.de/recordmydestop-out-2.ogv
Die Programme sind im Grunde Endlosschleifen, die ewig laufen, wenn man sie auf einen Speicher loslässt, der einen Ring darstellt.
Für die, die BF nicht kennen: Das ist mWn die kleinste Turing-vollständige Programmiersprache, d. h. dass mit BF prinzipiell jedes Problem gelöst werden kann. Wer's genauer wissen will, gucke hier vorbei.
Gruß
Gregor
Aus meiner Wühlkiste:
class FlankenErkennung
{
private:
bool state = false;
public:
bool doTrigger(const bool trigger)
{
bool result = trigger && !state;
state = trigger;
return result;
}
};
Hallo,
noch ne Lösung!
Zur Erklärung ist ja eigendlich schon alles gesagt. Du benötigst eine Variable die den Zustand des letzten Durchlaufs speichern kann und mit dem akuellen neuen Zustand vergleicht. Insofern war Dein Ansatz ja fast richtig.
Wenn man das in eine Funktion packt kann das so aussehen.
die Fuktion hat einen return Wert der TRUE ist wenn die Flanke erkannt wurde.
boolean posflanke( boolean input, boolean &hilfsmerker)
Der erste Parameter input ist eine Eingabe, hier der Pegel des Tasters.
Der zweite ist Ein und Ausgabe. (& vor dem Namen der Variablen)
in dem Beispiel wird ein Taster abgefragt. Mit jedem Betätigen wird ein Zähler um 1 erhöht. Ohne Flankenerkennung würde so lange hochgezählt wie der Taster gedrückt ist. Mit dem Monitor werden die Zustände angezeigt.
Wenn Du die Funktion so wie sie ist mehrfach benötigst, und das ist u.A ist der Sinn von Funktionen, kannst Du sie für unterschiedliche Input Signale mit unterschiedlichen Parametern mehrfach aufrufen.
pflanke1=posflanke(signal1,flag1)
pflanke2=posflanke(signal2,flag2)
Das Ganze geht natürlich auch für negative Flanken mit einer ähnlichen Funktion.
Gruß Heinz
// Testprogram positive Flankenerkennung
// ein Zähler wird mit jeder Flanke erhöht
int taster = 3; // Taster liegt auf pin 3 und 0V
boolean pegel; // Variable für Tastersignal
boolean pflanke;// Variable für pos. Flanke
boolean flag1; // Hilfsmerker
int count; // counter zum testen
void setup() {
Serial.begin(9600);
pinMode(taster, INPUT); // pin 3 ist ein Eingang
}
void loop() {
// Anzeige nur zum testen
Serial.print(pegel); Serial.print("\t");
Serial.print(flag1); Serial.print("\t");
Serial.println(count);
// Taster invertiert lesen (Taster schaltet nach 0V)
pegel = !digitalRead(taster);
// Function aufrufen
pflanke = posflanke(pegel, flag1);
// bei pos. flanke zähler erhöhen
if (pflanke) {
count++;
}
}
// ================ functon´s =================
boolean posflanke( boolean input, boolean &hilfsmerker) {
if (input && !hilfsmerker ) { // wenn Signal True und hilfsmerker false
hilfsmerker = true; // Zustand von Signal abspeichern
return true; // Funktion mit Rückgabe true verlssen
}
if (!input) { // wenn Signal False ist Hilfsmerker auch auf false setzten
hilfsmerker = false;
}
return false; // funktion mit Rückgabe false verlassen
}
Erweiterte Moeglichkeit der FlankenErkennung nach combie's Entwurf.
//class design created by combie
class FlankenErkennung
{
private:
bool state;
int16_t zaehler;
public:
void begin()
{
state = false;
zaehler = 0;
}
void aktZaehler(const int16_t ivar)
{
if (ivar == 0) zaehler = 0; //bei 0 = RESET
else zaehler += ivar; //+/- moeglich
}
bool doTrigger(const bool trigger)
{
bool result = trigger && !state;
state = trigger;
return result;
}
int16_t getZaehler()
{
return zaehler;
}
};
FlankenErkennung FE_1; //Objekt anlegen (FE_1)
//FlankenErkennung FE_2...;
const uint8_t pin_2 = 2; //fuer Flanken Auswertung
void setup()
{
pinMode(pin_2, INPUT);
FE_1.begin(); //Variablen initialisieren
}
void loop()
{
if (FE_1.doTrigger(digitalRead(pin_2))) FE_1.aktZaehler(1);
int16_t FE_1_zaehler = FE_1.getZaehler();
//...
}
Gruß
Grillgemuese
Flanken erkennen und zählen, mit der CombieLib
#include <CombiePin.h>
#include <CombieTimer.h>
#include <CombieTools.h>
using Combie::Tools::FlankenErkennung;
using Combie::Timer::EntprellTimer;
using EingabeTaster = Combie::Pin::TasterGND<2>; // Taster zwischen Pin und GND(invertierend)
using Counter = Combie::Tools::Counter<uint16_t>;
EingabeTaster taster;
EntprellTimer entprellen(20);
FlankenErkennung flankenerkennung;
Counter counter;
auto callBack = [](Counter &counter) // Lambda Funktion
{
Serial.println(counter);
};
void setup()
{
Serial.begin(9600);
taster.initPullup();
counter.onCount(callBack);
}
void loop()
{
counter = flankenerkennung = entprellen = taster;
}
CombieLib.zip (50.8 KB)