einfache und übersichtliche Flanken erkennung

[gedenk (Gast)]

Guten Abend,
ich bin auf der Suche nach einer einfachen und übersichtlichen Erkennung 
von Flanken in C.
Ich möchte Flanken erkennen die nicht schneller als meine Main Loop.
Mir geht es dabei einfach um eine übersichtliche Art auf ein Ereignis 
nur beim Flankenwechsel zu reagieren.

Ein Beispiel wäre das ein Fehlerbit erkannt wird und einmal eine 
Debugausgabe gesendet wird.

Habt ihr hier zu eine Funktion die man sich für solche Zwecke 
referenzieren kann?

Danke für die Hilfe

[Stefan F. (Gast)]

Eine Funktion, um eine simple Zustands-Variable zu beschreiben?

Also wenn das einfach sein soll, dann würde ich mal sehr gerne sehen, 
wie du das bisher programmiert hast.

uint8_t errorAlreadyProcessed=0;

int main()
{
    ...
   for (;;)  // main loop
   {
       ...
       if (error==1)
       {
          if (errorAlreadyProcessed==0)
          {
             errorAlreadyProcessed=1;
             processError();
          }
       }
   }

Wie soll man das mit einer zusätzlichen Funktion verschönern? Kann ich 
mir nicht vorstellen.

[Alex D. (allu)]

gedenk schrieb:
> Ich möchte Flanken erkennen die nicht schneller als meine Main Loop.

Einmal in der Main Loop den "Flankeneingang" abfragen und das Ergebnis 
in ein Register links reinschieben. Mit "and" 3 Länge die Länge 
begrenzen. Mit compare 01 oder 10 auf die gewünschte Flanke prüfen.

[gedenk (Gast)]

Das Problem ist das man sich Händisch immer eine Variable merken anlegen 
muss uns sich den Zustand merken muss.

[Stefan F. (Gast)]

gedenk schrieb:
> Ein Beispiel wäre das ein Fehlerbit erkannt wird und einmal eine
> Debugausgabe gesendet wird.

Das klingt für mich nicht danach, dass du jede Flanke erkennen willst, 
sondern nur die erste steigende. Darauf bezog sich mein obiges Beispiel.

[Alex D. (allu)]

gedenk schrieb:
> Das Problem ist das man sich Händisch immer eine Variable merken anlegen
> muss uns sich den Zustand merken muss.

Natürlich muss man den vorherigen Zustand kennen, wie sollte man sonst 
eine Änderung erkennen können ?

[ihr tiefer und voller Klang (Gast)]

gedenk schrieb:
> Ich möchte Flanken erkennen die nicht schneller als meine Main Loop.

Jede Flanke ist schneller als die main loop ->

if (false) passiert_eh_nie;

[gedenk (Gast)]

Bei vielen Spsen gibt es RTrig Ftrig das sind Funktionen die intern den 
Zustand speichern aber von extern kommt nur das zu Triggernde Signal 
rein.

[Peter D. (peda)]

gedenk schrieb:
> Das Problem ist das man sich Händisch immer eine Variable merken anlegen
> muss uns sich den Zustand merken muss.

Ohne Variablen läßt sich nunmal schlecht programmieren.
Du kannst Dir ein Macro schreiben, was für Dich die Variable anlegt.

[kiss (Gast)]

gedenk schrieb:
> ich bin auf der Suche nach einer einfachen und übersichtlichen Erkennung
> von Flanken in C.

Per ISR, dessen Interrupt nur bei einer Flankenart getriggert wird.

[Peter D. (peda)]

Anbei mal ein einfaches Macro zur Flankenerkennung.

[gedenk (Gast)]

Peter D. schrieb:
> Anbei mal ein einfaches Macro zur Flankenerkennung.

Danke für das Makro:)
 Ich kann es im Moment nnicht testen da ich keine Hardware da habe.
Verstehe ich es richtig das man so Zb das Makro verwenden könnte?

if (get_edge(PINB & (1<<0))==RISE)
  {
    uputs_("PINB0 RISE\n\r");
  }

Danke für die Hilfe

[NichtWichtig (Gast)]

gedenk schrieb:
> Das Problem ist das man sich Händisch immer eine Variable merken
> anlegen
> muss uns sich den Zustand merken muss.

Das ist nicht das Problem sondern die Lösung!

Ist der neue Wert anders als der alte bedingt nunmal das der Rechner 
beide vergleichen kann.

[gedenk (Gast)]

NichtWichtig schrieb:
> Das ist nicht das Problem sondern die Lösung!
>
> Ist der neue Wert anders als der alte bedingt nunmal das der Rechner
> beide vergleichen kann.

Ist mir schon bewusst;)
Ich war nur auf der Suche nach einem System wo ich nicht Händisch diese 
Variable anlegen muss.

Peter D. schrieb:
> Anbei mal ein einfaches Macro zur Flankenerkennung.

Dies gefällt mir vom Prinzip her gut muss es jetzt testen.

[Stephan (Gast)]

gedenk schrieb:
> ch war nur auf der Suche nach einem System wo ich nicht Händisch diese
> Variable anlegen muss.

Dich zwingt Niemand dazu. Du kannst auch eine Speicherstelle/ Bit direkt 
ansprechen.

[gedenk (Gast)]

Stephan schrieb:
> Dich zwingt Niemand dazu. Du kannst auch eine Speicherstelle/ Bit direkt
> ansprechen.

was meinst du damit?

[Einer K. (Gast)]

gedenk schrieb:
> Ich war nur auf der Suche nach einem System wo ich nicht Händisch diese
> Variable anlegen muss.
Irgendwas musst du aber tun!
Telepathie, können unsere µC noch nicht.

Ansonsten kann ich dir nur eine bequeme C++ Lösung anbieten.
Im Anhang, ein Beispiel.

[Guggel (Gast)]

Ihr nehmt blos die flasche Sprache.

if rising_edge(clk) then  
   if (count = 24) then  
      count <= 0;  
      clk_temp<= not clk_temp;  
   else  
      count <= count +1;  
   end if;  
end if;

So einfach kann das Leben sein!

[gedenk (Gast)]

Danke Euch.
Aber viele verstehen meine Frage falsch.
Ich weiß das man zur Flanken erkennung den vorherigen Zustand wissen 
muss.
Mir hat legendlich die Idee gefehlt wie man eine Flankenerkennung als 
eine Art "Funktion" bzw Makro macht um nicht für jede Flanke die man 
auswerten will jedes mal händisch eine Variable anlegen muss.

Die Lösung von Peter D.
Erfüllt genau meine Anforderung.
Die Merker Variable wird für jede Verwendung deklariert.

Und nein ich will keine Entprellung. Ich möchte nur eine 
Flankenerkennung.

Danke schönen Tag

[Peter D. (peda)]

Arduino Fanboy D. schrieb:
> Ansonsten kann ich dir nur eine bequeme C++ Lösung anbieten.

Ich habs zwar nicht probiert, aber der AVR-GCC wird mir bestimmt 1000 
Fehlermeldungen vor den Latz knallen.

Wie heißen denn die dafür nötigen Libs und wo kann man sie downloaden?

Es fällt mir doch sehr oft auf, das C++ Codebeispiele out of the box 
erstmal nicht lauffähig sind und daher gerade für Anfänger keine Hilfe.

[Martin V. (oldmax)]

Hi
C ist nicht meine Sprache und trotzdem mal einen Tip zur 
Flankenerkennung. Angenommen, du hast die Variablen "Alt" und "Neu" 
sowie "Temp", "Fl_to_1" und "Fl_To_0".
Zuerest eine Exclusiv-Oder "Alt" mit "Neu" und das Ergebnis nach "Temp".
Nun mit "Temp" und "Alt" eine Und-Verknüpfng und du hast den Wechsel von 
"1" nach "0". Dann eine Und-Verknüpfung von "Temp" und "Neu" und du hast 
den Wechsel von "0" nach "1". Anschließend kopierst du "neu" nach "Alt". 
Die Bits in den Variablen "Fl_to_1" sowie "Fl_to_0" kannst du jetzt 
abfragen, die Bearbeitung ausführen und diese Bits löschen. Erst bei 
einem erneuten Wechsel in der Variable "Neu" werden sie wieder in der 
Flanke erkannt und neu gesetzt. In Assembler etwa 10 Anweisungen, wobei 
hier immer von Bytes und nicht von Bits die Rede ist.

Flanken:  ; In "Alt" und "Neu", Out "Fl_to_1" und "Fl_to_0"
  LDS  r16, alt
  LDS  r17, neu
  EOR  r16,r17
  Mov  temp, r16  ;temp = beliebiges Register
  AND  r16, r17      ; 
  STS  Fl_to_1, r16  ; Ergebnis Flankenbits "0" nach "1"
  LDS  r16, alt
  AND  r16, temp
  STS  Fl_to_1, r16  ; Ergebnis Flankenbits "1" nach "0"
        STS     alt, r17
RET

Ich denk, in C ist das auch nicht viel schwieriger.
Gruß oldmax

[Einer K. (Gast)]

Peter D. schrieb:
> Wie heißen denn die dafür nötigen Libs und wo kann man sie downloaden?

Die kannst du bei mir bekommen!

Und dann wirft dein Kompiler auch keine Meldungen mehr.
C++11 sollte er dafür schon können, und einen der üblichen AVR Arduinos 
solltest du verwenden.

[Stefan F. (Gast)]

Statt Makro-Magie könnte man sich auch einfach eine ganz normale 
Funktion schreiben. Das mag altmodisch wirken, aber C ist ja auch eine 
altmodische Programmiersprache - passt also.

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>

bool zustand_Schalter1=0;

/**
 * Erkennt Flankenwechsel bei einem Signal.
 * @param signal Eingangssignal
 * @param zustandsVariable Zeiger auf eine Variable, die den vorherigen Zustand speichert.
 * @return 1 bei stegender Flanke, -1 bei fallender Flanke, 0=keiner Änderung
 */
int8_t flanke(bool signal, bool* zustandsVariable)
{
    if (signal != *zustandsVariable)
    {
        *zustandsVariable=signal;
        if (signal)
           return 1;
        else
           return -1;
    }
    return 0;
}

void test_fuer_schalter1(bool signal)
{
    int8_t f=flanke(signal, &zustand_Schalter1);
    switch (f)
    {        
        case +1: printf("steigende Flanke"); break;
        case -1: printf("fallende Flanke"); break;
        default: printf("keine Flanke");
    }
}

int main()
{
    test_fuer_schalter1(0);
    test_fuer_schalter1(1);
    test_fuer_schalter1(1);
    test_fuer_schalter1(0);
    test_fuer_schalter1(0);
}

In Kombination mit einem I/O Pin könnte man das so verwenden:

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <util/delay.h>
#include <avr/io.h>

// Hier noch die Funktion "flanke" rein kopieren oder inkludieren.

bool zustand_taster=0;
int zaehler=0;

int main()
{
    for(;;) // forever loop
    {
        uint8_t signal=PINB & (1<<PB0);
        if (flanke(signal, &zustand_taster) == 1)
        {
           zaehler++;
           printf("Zaehlerstand: %d", zaehler);

           // entprellen
           _delay_ms(10);
        }
    }
}

[Apollo M. (Firma: @home) (majortom)]

Peter D. schrieb:
> Anbei mal ein einfaches Macro zur Flankenerkennung.

static bool last_flag = false; /* new variable on every macro usage*/

das macro sollte hier mit "__LINE__" verbessert werden, damit 
automatisch immer eine neue variable angelegt wird!

mt

[kiss (Gast)]

gedenk schrieb:
> Bei vielen Spsen gibt es RTrig Ftrig das sind Funktionen die intern den
> Zustand speichern aber von extern kommt nur das zu Triggernde Signal
> rein.

Man könnte auch einfach das Interrupt Flag eines zB AVR in der main 
abfragen (und löschen). Das speichert entsprechend der Konfiguration das 
Triggerereignis.

[Tobi P. (Gast)]

gedenk schrieb:
> ich bin auf der Suche nach einer einfachen und übersichtlichen Erkennung
> von Flanken in C.

du kannst keine Flanken erkennen, du kannst nur logische Zustände 
vergleichen. Daraus kann man sich eine Pseudo- Flankenerkennung basteln 
indem man eine Zustandsänderung sucht.

wenn (PortWert != alterWert) Aenderungsflag = 1;
alterWert= PortWert;

Damit findet man aber nur die erste Änderung

wenn (PortWert != alterWert) Aenderungszaehler++;
alterWert= PortWert;

Bildet die Anzahl der Änderungen


Es kann sinnvoll sein einen Interrupt zu verwenden, der erkennt aber 
Änderungen meist nur in eine Richtung.

Viele Controller haben Onchange Register die eine Änderung der Ports 
seit der letzten Abfrage anzeigen. Das hat aber nichts mit C zu tun und 
ist "nicht portabel".

[Peter D. (peda)]

Apollo M. schrieb:
> das macro sollte hier mit "__LINE__" verbessert werden, damit
> automatisch immer eine neue variable angelegt wird!

Wozu soll das gut sein?
Jede static Variable hat nur innerhalb des Blocks Gültigkeit und bleibt 
bis zum nächsten Eintritt in den Block erhalten.
Der Linker ist daher verpflichtet, bei jeder Macroexpansion eine neue 
Adresse zu vergeben und er macht das auch.

char foo(char flag)
{
  76:  90 91 61 00   lds  r25, 0x0061
// ...
char faa(char flag)
{
  9e:  90 91 60 00   lds  r25, 0x0060

[Peter D. (peda)]

Arduino Fanboy D. schrieb:
> Die kannst du bei mir bekommen!

Private Libs würde ich immer so kenntlich machen:

#include "CombiePin.h"
#include "CombieTimer.h"
#include "CombieTools.h"

Dann muß man nicht erst vergeblich danach suchen.

[Frank M. (ukw) (Moderator)]

Apollo M. schrieb:
> das macro sollte hier mit "__LINE__" verbessert werden, damit
> automatisch immer eine neue variable angelegt wird!

Wie Peter dargelegt hat, ist das nicht notwendig. Du kannst ohne 
Probleme beliebig viele gleichnamige (static-)Variablen innerhalb einer 
Funktion anlegen und auch getrennt voneinander verwenden, solange sich 
nicht der Scope überlappt.

[Einer K. (Gast)]

Peter D. schrieb:
> Private Libs würde ich immer so kenntlich machen:

Die Libs sind dafür vorgesehen in einen der Arduino Library Ordner 
geworfen zu werden.
Sie sind dann also für alle Projekte zu sehen.


#include "abc.h"
Nutze ich für Dateien, welche nur in diesem Projekt sichtbar sind.
Im Projekt Ordner liegen.


#include <abc.h>
Um Libs aus den "öffentlichen" libraries zu verwenden. Wo man die Combie 
Libs auch hinein werfen sollte.

Eine dritte Möglichkeit der Unterscheidung bietet sich nicht.

[Apollo M. (Firma: @home) (majortom)]

Peter D. schrieb:
> Wozu soll das gut sein?
> Jede static Variable hat nur innerhalb des Blocks Gültigkeit und bleibt
> bis zum nächsten Eintritt in den Block erhalten.
> Der Linker ist daher verpflichtet, bei jeder Macroexpansion eine neue
> Adresse zu vergeben und er macht das auch.

korrekt, die blockklammerung habe ich übersehen. also in die tonne mit 
meiner anmerkung!


mt

[Peter D. (peda)]

Stefanus F. schrieb:
> Statt Makro-Magie könnte man sich auch einfach eine ganz normale
> Funktion schreiben.

An dem Macro ist überhaupt nichts magisches. Der Code ist 
straightforward und deutlich einfacher zu verstehen, als das C++ 
Beispiel.
Nicht jedem bekannt ist vielleicht, daß man Macros auch lesbar schreiben 
darf, indem man sie mit dem '\' Zeichen auf mehrere Zeilen umbricht.
Der eigentliche Trick des Macros ist aber, daß es ein Block öffnet und 
darin eine Variable anlegt. Somit wird bei jeder Verwendung automatisch 
eine neue Variable erzeugt.
Als Magie würde ich das nicht bezeichnen.

Natürlich grassiert oft das Vorurteil, Macros sind ja ach so pöse. Dabei 
wird aber verkannt, daß selbst die standard Includes schon sehr viele 
Macros beinhalten.

[Stefan F. (Gast)]

Ich will das Makro nicht schlecht reden, sondern nur eine Alternative 
aufzeigen.

Ich mag Makros nicht mehr so sehr, nachdem ich mich mit zu vielen 
Verschachtelungen selbst verzettelt habe und andere Nutzer durch meine 
Quelltexte nicht durchgeblickt haben. Mit Bedacht eingesetzt sind sie 
sicher nicht grundsätzlich verkehrt.

[Frank M. (ukw) (Moderator)]

Stefanus F. schrieb:
> Ich will das Makro nicht schlecht reden, sondern nur eine Alternative
> aufzeigen.

Deine Alternative ist aber nur eine Alternative, wenn es nur einen Pin 
auszuwerten gilt. Peters Makro funktioniert aber auch für 2, 3, 4 Pins. 
Hier wird der Code n-fach durch den Preprocessor einfach dupliziert - 
nicht schön, aber wirksam.

Die allgemeinere Lösung über eine Funktion wäre daher wesentlich 
interessanter. Der Spezialfall N=1 ist dabei eher uninteressant. Da kann 
ich (fast) Peters Makro einfach in eine leere Funktion kopieren und 
fertig.

[Einer K. (Gast)]

Frank M. schrieb:
> Die allgemeinere Lösung über eine Funktion wäre daher wesentlich
> interessanter.

Ich betrachte den Flankenerkenner als endlichen Automaten.
Vielleicht die primitivste Form dessen, aber ein Automat.

Das bedingt, dass man irgendwo einen Zustand halten muss.

Hält man den Zustand in der Funktion (static), schränkt das die 
Mehrfachverwendung ein. Wie bei den Makros führt das recht zwingend zu 
Codeduplikaten, für jeden "Kanal" welcher überwacht werden möchte.


Die für "mich" sinnvollste Lösung wäre in C eine Variable außerhalb, für 
den Zustand. z.B. Übergabe eines Zeigers auf den Zustand.

In C++ hält man den Zustand als Instanz Eigenschaft. Dürfe die übliche 
Vorgehensweise sein.


----
Im Grunde sind das die drei Möglichkeiten, welche einem die µC Welt 
bietet.
Mehr sehe ich nicht.

Geschickt gebaut, kann man so auch z.B. 8 Kanäle gleichzeitig in einem 
Byte verwalten.

Natürlich kann man das auch in ASM oder einer anderen Sprache erledigen, 
ändert aber nichts an den Notwendigkeiten.

[Frank M. (ukw) (Moderator)]

Arduino Fanboy D. schrieb:
> Geschickt gebaut, kann man so auch z.B. 8 Kanäle gleichzeitig in einem
> Byte verwalten.

Jepp. Wenn man mit dem Speicher nicht geizen muss, gehts auch mit einem 
Array namens last_states[].

[max123 (Gast)]

Mein Vorschlag:
///////////////////////////////////////////////////////

#include<TimerOne.h>
//Entprellen und bei positiver Flanke wechset die LED
//an Pin 13.

// Hardware:
// Taster an Pin 8 und GND anschließen. (oder ein Stück Draht)

//Funktion 
//1. Falls Taster gedrückt => Zähler (z)wird erhöht
//   Falls Taster offen -> Zähler (z)wird vermindert
//2.Der Wertebereich von z wird begrenzt. (mit constrain)
//3. Umschaltpunkte werden für den Schalter festgelegt.
//Hat der Zähler mehr als 80, wird der Schalte swi auf
//eins gelegt.Bei einem Zählerstand von weniger als 20,
//hat der Schalter den Wert 0. (Hysterese)
//4. Ist der alte Zählerstand swi = 0 und der neue 1,
//ist eine pos. Flanke vorhanden. 
//5. Bei einer pos.Flanke wird die LED an Pin 13 
//umgeschaltet (toggel).
//6.Damit beim nächsten Schleifendurchlauf der alte
//Schalterzustand zur Verfügung steht, wird der aktuell 
//Zählerstand auf swialt gespeichert

int swi, swialt; 
int z;                     
int gedruekt;
int i;
void my_isr(void)   //Interrupt Service 
{ if ( digitalRead(8))
    z++;
  else
    z--;

  z = constrain(z, 0, 100);

  if (z > 80)
    swi = 1;

  if (z < 20)
    swi = 0;

  //Serial.println(swi);

  if ( swi == 1  && swialt == 0)
   {
    i++;
    digitalWrite(13, i&1);
    
   }
Serial.println(swi);

  swialt = swi;   //Rueckspeichern
 // delay(1);
}
  
 

void setup()
{ pinMode(13, OUTPUT);
  pinMode(8, INPUT_PULLUP );
  Serial.begin(38400);
  (!Serial)
  ;
  Timer1.initialize(200); // .2 ms Interrupt von Timer 1
  Timer1.attachInterrupt(my_isr);
}

void loop ()
{
  if ( digitalRead(8))
    z++;
  else
    z--;

  z = constrain(z, 0, 100);

  if (z > 80)
    swi = 1;

  if (z < 20)
    swi = 0;

  //Serial.println(swi);

  if ( swi == 1  && swialt == 0)
   {
    i++;
    digitalWrite(13, i&1);
    
   }
Serial.println(swi);

  swialt = swi;   //Rueckspeichern
 // delay(1);
}