Aus einer while Schleife springen

[Huber M. (michael_h784)]

Hallo,

ich habe folgendes vor. Ich möchte mit einem Taster zwei Kanäle hin und 
her schalten.Und dazwischen eine von mir definierte Wartezeit eingeben.

-wenn Taster nicht gedrückt
-schalte PA7 und PA3 aus
-warte
-schalte PA3 ein

-wenn taster gedrückt
-schalte PA3 und PA7 aus
-warte
-schalte PA7 ein

wenn ich keine zeitverzögerung haben wollte, ja gar kein Problem für 
mich wäre.
jetzt habe ich, aber bei meinem Code das Problem das ich aus der letzten 
while Schleife nicht mehr raus komme. wie kann ich das abändern. ?

/*
 * GccApplication10.c
 *
 * Created: 16.10.2016 11:55:50
 *  Author: huber
 */ 

#define F_CPU 1000000UL
#include <util/delay.h>
#include <avr/io.h>

#define  warte 4000

uint8_t x = 2;


int main(void)
{   DDRA = (1<<PA3)|(1<<PA7);
  PORTA = (1<<PA0);
    
  
  
  while(1)
    {  
    
    anfang();
    
        if ((PINA &(1<<PA0)))
        {   
      
      PORTA &= ~(1<<PA7);
      PORTA &= ~(1<<PA3);
      //_delay_ms(warte);
      while(1)
      {
        PORTA |= (1<<PA3);
        
        if (!(PINA & (1<<PA0)))
                {   
      
            PORTA &= ~(1<<PA3);
            PORTA &= ~(1<<PA7);
            //_delay_ms(warte);
            while(1)
            {
           PORTA |= (1<<PA7);
          
            }
      
               }
      }
      
        } 
        
    }
}

bei diesem Code klappt zwar das Umschalten mit Verzögerung, aber es 
verzögert sich auch die Zeit nach dem er gedrückt oder nicht gerdrückt 
wurde bis er in den eigentlichen Zustand fällt.Weil er halt die while 
Schleife erst zu ende durchläuft. Wie könnte ich denn das abändern.?

/* Hallo, an mich;

also mein code soll nachfolgendes machen.:

Taster nicht gedrückt
   schalte PA7 aus
   warte eine zeit
   schalte PA3 ein
   
   Taster gedrückt
   schalte PA3 aus
   warte eine zeit
   schalte PA7 ein
   
   jetzt habe ich folgendes Problem, wenn ich den taster drücke,
   geht er nicht sofort in den anderen zustand und umgekehrt. Wie kann ich das ändern.?
   
   Im prinzip möchte ich mit einem Taster zwischen zwei Kanäle umschalten. Und es soll dabei der jeweills gewhälte
   Kanal erst aus sein, und nach einer von mir definierten zeit dann einschalten. Und der nicht gewählte kanal natürlich aus.
 * GccApplication9.c
 *
 * Created: 16.10.2016 09:50:31
 *  Author: Daniela Weinhart
 */ 
#define  F_CPU 1000000UL
#include <util/delay.h>
#include <avr/io.h>

#define p  20
#define umschaltzeit 5000

uint8_t x=0;

int main(void)
{
  DDRA = (1<<PA3) | (1<<PA7);
  PORTA = (1<<PA0);
  
  void auf (void)
  {
    if ((PINA &(1<<PA0)))
    { _delay_ms(p);
      
      PORTA &= ~(1<<PA7);
      _delay_ms(umschaltzeit);
      x = 1;
      
       if (x == 1)
       {
        PORTA |= (1<<PA3);
       }
      
    }
  
    
  }
  
  void ab (void)
  {
    if (!(PINA &(1<<PA0)))
    {_delay_ms(p);
      
    PORTA &= ~(1<<PA3);
    _delay_ms(umschaltzeit);
    x = 2;
    
       if (x == 2)
       {
      PORTA |= (1<<PA7);
       }
      
    }
    
  }
  
  
    while(1)
    {
    auf();
      ab();
    
    }
}

grüsse Huber

[Wegstaben V. (wegstabenverbuchsler)]

definiere ein Flag "Abbruchbedingung", welches auf "true" gesetzt wird, 
sobald die Abbruchbedingung zutrifft.

und deine Abfrage geht dann auf

while !(Abbruchbedingnung)
{
   mache irgendwas
}

[nicht"Gast" (Gast)]

oder break

[nicht"Gast" (Gast)]

Wegstaben V. schrieb:
> while !(Abbruchbedingnung)
> {
>    mache irgendwas
> }

ach, und das gibt einen Fehler.
Richtig ist:

bool Abbruchbedingnung = false;
while (!Abbruchbedingnung)
{
   mache irgendwas
   if (ichwillnichtmehr)
   {
      Abbruchbedingnung = true;      
   }
}

PS: Habs auch gleich mal Vervollständigt

[Mitlesa (Gast)]

Huber M. schrieb:
> grüsse Huber

Das hat man dir schon mal gesagt .....

Ich hab "in der Schule" gelernt dass man in C nicht Funktionen
innerhalb von Funktionen definieren darf. Dass der Compiler das
geschachtelte frisst ist erstaunlich, aber das Verhaltens-Ergebnis
ist schlichtweg undurchsichtig ...... und vermutlich irritierend.

[Rolf M. (rmagnus)]

Mitlesa schrieb:
> Ich hab "in der Schule" gelernt dass man in C nicht Funktionen
> innerhalb von Funktionen definieren darf. Dass der Compiler das
> geschachtelte frisst ist erstaunlich

Es gibt Compiler, die das als Erweiterung unterstützen, aber 
Standardkonform ist es nicht.

[Huber M. (michael_h784)]

wenn ich wüsste wie ich es anders lösen könnte, würde ich es machen.

Im prinzip möchte ich mit einem Taster zwischen zwei Kanäle umschalten. 
Und es soll dabei der jeweills gewhälte
   Kanal erst aus sein, und nach einer von mir definierten zeit dann 
einschalten. Und der nicht gewählte kanal natürlich aus.

[Peter D. (peda)]

Huber M. schrieb:
> -wenn Taster nicht gedrückt
> -schalte PA7 und PA3 aus
> -warte
> -schalte PA3 ein
>
> -wenn taster gedrückt
> -schalte PA3 und PA7 aus
> -warte
> -schalte PA7 ein

Das geht nicht.
Du mußt schon sinnvolle Regeln aufstellen.
Ein Taster kann nur gedrückt oder nicht gedrückt sein.
D.h. die 2.Zeile in beiden Bedingungen schaltet ständig alles aus. Und 
nach dem Delay geht einer für wenige µs kurz an, bis wieder die 2.Zeile 
erreicht wird.
Regeln für den MC müssen immer eindeutig sein. Erst dann kann man sie 
auch programmieren.

Generell fragt man Tasten nicht direkt im Code ab, sondern überläßt das 
einer Entprellroutine, die entprellt und die Tastenereignisse (Events) 
für das Main aufbereitet.
Für verzögerte Aktionen nehme ich einen Scheduler.
Man kann aber auch Statemachines nehmen, die z.B. in einem 10ms 
Zeitraster aufgerufen werden.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Huber M. schrieb:
> Im prinzip möchte ich mit einem Taster zwischen zwei Kanäle umschalten.
> Und es soll dabei der jeweills gewhälte Kanal erst aus sein, und nach
> einer von mir definierten zeit dann einschalten.
Kannst du das mal statt in Prosa in einem Timing-Diagramm darstellen? 
Sowas liest sich irgendwie leichter...

> wenn ich wüsste wie ich es anders lösen könnte, würde ich es machen.
Du hast den falschen Ansatz für die Lösung deiner Aufgabe. Stichworte 
für den richtigen Ansatz sind: Endlicher Automat, Zustandsautomat, FSM, 
State Machine

Ein üblicher und leicht erweiterbarer Code sieht also so aus, dass die 
Hauptschleife ständig (schnellstmöglich ohne delay()!) durchlaufen wird 
und darin dann lediglich abgefragt wird, ob z.B. wegen einer 
abgelaufenen Zeit oder wegen äusseren Eingaben (z.B. Taster, Sensoren) 
Aktionen nötig sind. Dazu braucht es aber als "Infrastruktur" einen 
Zeitgeber, der z.B. in einem Interrupt einen ms-Zähler (oder 
Hundertstelsekunden oder Zehntelsekunden...) hochzählt.
Beim Arduino gibt es dafür die Funktion millis(), die die Millisekunden 
seit Power-On zurückgibt. Und dann kann man das so angehen:
https://learn.adafruit.com/multi-tasking-the-arduino-part-1/using-millis-for-timing
Und wenn du diesen Ansatz mit den Zeitdifferenzen und der schnell 
durchlaufenen Hauptschleife hast, dann findest du dann auch ganz schnell 
den Weg zur State Machine...

[Huber M. (michael_h784)]

Moing;

wäre das eine Möglichkeit die in die richtige Richtung geht? Hier wird 
es ja auch langsam, bzw. wo setze ich dann am besten das delay oder 
nochmal irgendwie mit Timer intterrupt?

/*
 * GccApplication46.c
 *
 * Created: 17.10.2016 10:40:32
 *  Author: Huber
 */ 

#define F_CPU 1000000UL
#include <util/delay.h>
#include <avr/io.h>
#include <avr/interrupt.h>

volatile uint8_t counter = 0; 
volatile uint8_t Flag = 0;

ISR(EXT_INT0_vect)
{
  Flag = 1;
}
int main(void)
{ DDRA = (1<<PA3)|(1<<PA7);
  PORTA = (1<<PA0);
 
 MCUCR |= (1<<ISC00);// jede änderung löst ISR aus
 GIMSK |= (1<<INT0);
 sei();
 
 
 void zaehler (void)
 {
   if (Flag == 1)
   {
     counter++;
     Flag = 0;
   }
 }
 
 void statemachine(void)
 {
  switch (counter)
  {
    
    case 1: PORTA &= ~(1<<PA3);counter = 2; break;
    case 2: /*_delay_ms(5000)*/; counter = 3; break;
    case 3: PORTA |= (1<<PA3);counter = 4; break;
    case 4:counter = 0; break;
    case 5:    ; break;
    case 6:    ; break;
    case 7:    ; break;
  } 
 }
 
 
 
 
 
 
  while(1)
  {
   statemachine();
   zaehler();
  }

}

[Nico W. (nico_w)]

Ließ dir einfach mal das hier durch. Ich habe mich da vor ein paar 
Monaten auch einmal durchgewühlt und finde den Artikel sehr gut 
beschrieben.

https://www.mikrocontroller.net/articles/Statemachine

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Nico W. schrieb:
> finde den Artikel sehr gut beschrieben.
Das Konzept selber ist dort hübsch dargestellt.

Trotzdem sollte dabei im Hinterkopf behalten werden: die von mir 
erwähnte Zeitbasis ist dort beim Ampel-Beispiel einfach über das 
delay(1000) gemacht. Diese aktive Rechenzeitvernichtung mit dem delay() 
verhindert dann auch wirksam, dass z.B. ein Anforderungsknopf einer 
Fußgängerampel mit eingebunden werden kann. Denn der Fußgänger wird 
nicht mindestens 1 Sekunde lang auf den Anforderungstaster drücken. 
Sondern bestenfalls kurz mal draufhauen...

[Nico W. (nico_w)]

Lothar M. schrieb:
> Trotzdem sollte dabei im Hinterkopf behalten werden: die von mir
> erwähnte Zeitbasis ist dort beim Ampel-Beispiel einfach über das
> delay(1000) gemacht.

Was hindert dich daran das alles über einen Interrupt alle 1000ms oder 
so aufzurufen?

[Huber M. (michael_h784)]

ok, das ist jetzt die Statemaschine mit der Ampel. Und auch in meinem 
buch ist es ebenfalls mit delay in der Schleife. Nun meine Frage mit 
welchen Interrupt kann ich das delay ersetzen zb.TCNT. und wie setzte 
ich das dann ein. bzw. welchen verendet man dazu vielleicht komme ich 
dann von alleine drauf.

#define F_CPU 80000000UL
#include <avr/delay.h>
#include <avr/io.h>

enum ampel{rot=1,rot_gelb,gelb, gruen};
char zustand = 1;

void ampel1(ampel)
{
  switch(ampel)
  {
    case rot     : PORTB = (1<<PB0);          break;
    case rot_gelb: PORTB = (1<<PB0)+(1<<PB1); break;
    case gelb    : PORTB = (1<<PB1);          break;
    case gruen    : PORTB = (1<<PB2);         break;
  }
}

void ampel2(ampel)
{
  switch(ampel)
  {
    case rot     : PORTD = (1<<PD0);          break;
    case rot_gelb: PORTD = (1<<PD0)+(1<<PD1); break;
    case gelb    : PORTD = (1<<PD1);          break;
    case gruen    : PORTD = (1<<PD2);          break;
  }
}

void state_machine(void)
{
  enum ampel ampel_1, ampel_2;
  
  switch (zustand)
  {
    case 1: ampel1(ampel_1 = rot);
            ampel2(ampel_2 = gruen);
        zustand = 2;
        break;
        
    case 2: ampel1(ampel_1 = rot);
            ampel2(ampel_2 = gelb);
            zustand = 3;
            break;  
    
    case 3: ampel1(ampel_1 = rot);
            ampel2(ampel_2 = rot);
            zustand = 4;
            break;    
    
    case 4: ampel1(ampel_1 = rot_gelb);
            ampel2(ampel_2 = rot);
            zustand = 5;
            break;
    
    case 5: ampel1(ampel_1 = gruen);
            ampel2(ampel_2 = rot);
            zustand = 6;
            break;
        
    case 6: ampel1(ampel_1 = gelb);
            ampel2(ampel_2 = rot);
            zustand = 7;
            break;  
        
      case 7: ampel1(ampel_1 = rot);
              ampel2(ampel_2 = rot);
              zustand = 8;
              break;  
        
      case 8: ampel1(ampel_1 = rot);
              ampel2(ampel_2 = rot_gelb);
              zustand = 1;
              break;    
          
  }
}

int main (void)
{
  DDRB = 0x07;
  DDRD = 0x07;
  
  while (1)
  {
    state_machine();
    _delay_ms(3000);
  }
  
}

[Nico W. (nico_w)]

Nicht das erste Beispiel nehmen. Das letzte!

// 1ms bei 16MHz
#define TICK_TIME 16000

void timer_init() {
  TCCR1A = MASK(CS10);
  OCR1A = TICK_TIME; // 1ms bei 16MHz

  TIMSK1 = MASK(OCIE1A); // enable interrupt
}

ISR(TIMER1_COMPA_vect) {
  OCR1A = (OCR1A + TICK_TIME) & 0xFFFF;
  state_machine();
}

Ganz grob so. Der Code ist jetzt schnell dahin getippt. Fehler dürfen 
selbst gefunden und korrigiert werden.

Tick ist hier 1ms. Also dementsprechend den Zähler mal 1000 nehmen oder 
irgendwie anders über Prescaler oder so auf eine Sekunde erweitern. Je 
wie man das will und braucht.

// Tabelle fuer state machine
 
ampel_state_t state_table[8] = {
 
// AMPEL1 AMPEL2   Induktionsschleife ? 
// |         |       |   Wartezeit in s <- den hier mal 1000 z.B. um von ms auf s zu kommen
// |         |       |   |
// |         |       |   |   naechster Zustand     Name
//----------------------------------------------------------------------
{ROT     , GRUEN   , 1, 10,  OSTWEST_GELB},        // OSTWEST_GRUEN
{ROT     , GELB    , 0,  1,  ALLE_ROT_1},          // OSTWEST_GELB
{ROT     , ROT     , 0,  3,  NORDSUED_ROTGELB},    // ALLE_ROT_1
{ROTGELB , ROT     , 0,  1,  NORDSUED_GRUEN},      // NORDSUED_ROTGELB
{GRUEN   , ROT     , 0, 10,  NORDSUED_GELB},       // NORDSUED_GRUEN
{GELB    , ROT     , 0,  1,  ALLE_ROT_2},          // NORDSUED_GELB
{ROT     , ROT     , 0,  3,  OSTWEST_ROTGELB},     // ALLE_ROT_2
{ROT     , ROTGELB , 0,  1,  OSTWEST_GRUEN}};      // OSTWEST_ROTGELB

[Huber M. (michael_h784)]

Nico W. schrieb:
> Ganz grob so. Der Code ist jetzt schnell dahin getippt. Fehler dürfen
> selbst gefunden und korrigiert werden.

ok das ist das was ich brauche. Jetzt habe ich einen 8 bit Timer mit 
Timer 0 im Normal Modus. Bei dem im sec. Takt an PB1 eine led toggled. 
Aus meinem buch.Da kann ich schneller etwas nachlesen. Und zum späteren 
Zeitpunkt mit der Statemaschine vereinigen. Ich habe das eigentlich 
alles soweit verstanden, wie ich glaube. Allerdings blinkt es nicht. 
Kann aber keinen fehler entdecken

#define F_CPU 8000000UL
#include <avr/io.h>
#include <avr/interrupt.h>

#define statusled (1<<PB1) // LED an PB1

uint8_t timer_overflow_counter = 0;

void init_timer_0 (void)
{
  TCCR0A = 0x00;                      // weil kein bit gesetzt werden muss für gewüschte Funktion
  TCCR0B = (1<<CS01) + (1<<CS00);     // Prescaler = 64 -> 8Mhz/64 = 125000
  TIMSK0 = (1<<TOIE0);              // Timer0 overflow interrupt enable
  TCNT0 = 131;                        // Timer mit 131 vorladen
}

int main(void)
{
  DDRB = 0xFF;        // PORTB Richtungsregister = Ausgang
  
  init_timer_0();     // Timer 0 initialisieren
  
  sei();              // Interrupts einschalten
  
  while(1)
  {
    asm ("NOP");    // Nichts tun
  }
}

ISR(TIMER0_OVF_vect)    // Timer Interrupt wird alle 1ms ausgeführt
{
  TCNT0 = 131;        // Timer0 erneut mit 131 vorladen
  
  if (timer_overflow_counter <= 999)   // Zählvariable 999 mal hochzählen
  timer_overflow_counter ++;
  
  else                                // Den else-Zweig beim 1000. Durchlauf (1 Sekunde) einmal ausführen
  {
    PORTB ^= statusled;             // Status LED toggeln
    timer_overflow_counter = 0;     // Zähler zurücksetzen
  }
}

[Route_66 H. (route_66)]

Huber M. schrieb:
> uint8_t timer_overflow_counter = 0;

Huber M. schrieb:
> if (timer_overflow_counter <= 999)   // Zählvariable 999 mal
> hochzählen

Huber M. schrieb:
> Kann aber keinen fehler entdecken

Immer noch nicht???

Selbst meine dreijährige Enkelin weiß, dass sie mit Ihren Fingern nicht 
alle Fussballer auf dem Platz zählen kann!

[Paul B. (paul_baumann)]

Huber M. schrieb:
> Kann aber keinen fehler entdecken

Ich habe zwar keine Ahnung von C, vermute aber, daß in den Datentyp 
"uint8_t" nur maximal 255 reinpasst. 999 wäre zu "dick" dafür.



MfG Paul

[Thomas E. (picalic)]

Route 6. schrieb:
> dass sie mit Ihren Fingern nicht
> alle Fussballer auf dem Platz zählen kann!

Kann man doch - mit den Fingern einer Hand kann man alle 22 Spieler und 
sogar den Schiedrichter und ein paar Linienrichter mitzählen. Für 999 
Marathonläufer braucht man allersdings schon die Finger beider Hände, 
ein Arbeiter vom Sägewerk, dem zwei Finger fehlen, könnte halt nur bis 
255 Marathonläufer zählen...

[Route_66 H. (route_66)]

Thomas E. schrieb:
> Kann man doch - mit den Fingern einer Hand kann man alle 22 Spieler und
> sogar den Schiedrichter und ein paar Linienrichter mitzählen.

Das weiß aber meine dreijährige Enkelin nicht, und auf diesem 
Wissensstand wollte ich dem TO seinen Denfehler aufzeigen.