Selbsthaltung durch Variable

[Bit (Gast)]

Hallo alle zusammen,
so ich stehe gerade dermaßen auf der Leitung und blicks gerade nicht 
mehr.
ich mochte eine selbst Haltung in c programmieren. Meine Idee ich 
benutze eine Variable um einen Zustand zu speichern.
Das Ergebnis sieht nun so aus:

#include <avr/io.h>
Int Einschaltet=0;
Int main (void){
DDRC &= ~(1<<PC0),~(1<<PC1),~(1<<PC2); // Eingang
PORTC = 0x00; // Ohne pulldownwid…
While(1){
  if (PINC & (1<<PC0)==1){ //  Bedingung = true führe die Schleife aus 
 Eingeschaltet=1;} // Variable Eingeschaltet wird der Wert 1 gegeben

 if (Eingeschaltet==1){ // Bedingung = true führe die Schleife aus
 s++;} // Zählt eine Variable nach oben (+1 pro Durchgang der schleife)

  }
}

Mein Problem ist nun folgendes, das nichts passiert wenn ich den Taster 
drücke, egal ob lange <1s oder nur kurz >1s.

Allerdings funktioniert folgendes:

#include <avr/io.h>
Int main (void){
DDRC &= ~(1<<PC0),~(1<<PC1),~(1<<PC2); // Eingang
PORTC = 0x00; // Ohne pulldownwiderstände
While(1){
  if (PINC & (1<<PC0)==1){ //  Bedingung = true führe die Schleife aus 
 s++;} // Zählt eine Variable nach oben (+1 pro Durchgang der schleife)
  }
}

Über jegliche Art tipp wäre ich sehr dankbar.

[Jörg W. (dl8dtl) (Moderator)]

Bit schrieb:
> Int Einschaltet=0;

C unterscheidet zwischen Groß- und Kleinschreibung.

Wie ist dein Typ „Int“ definiert?

> DDRC &= ~(1<<PC0),~(1<<PC1),~(1<<PC2); // Eingang

Du solltest dir die Funktion des Komma-Operators durchdenken.

Davon abgesehen: die Portpins eines AVRs (um den es offenbar geht)
stehen nach einem Reset auf Eingang.

> PORTC = 0x00; // Ohne pulldownwid…

… außerdem hat ein AVR keine Pulldowns sondern bestenfalls Pullups,
aber auch die sind nach Reset abgeschaltet.

>  Eingeschaltet=1

Oben hieß die Variable noch anders …

Bevor wir hier noch weiter deine Tippfehler suchen müssen: bitte
poste doch den Code, den du auch wirklich benutzt hast, in
compilierfähiger Form.

[Rainer U. (r-u)]

Was soll denn "passieren"? Oder hab ich übersehen wo Du eine Aktion / 
Ausgabe programmiert hast?

[eijach (Gast)]

Im Beispiel 1 wird die variable s nach dem Drücken des Tasters für immer 
hochgezählt. Man weiß den Datentyp von "s" ja nicht, aber der wird 
irgendwann überlaufen und wieder bei 0 beginnen.

Bei dem 2. Bsp. wird "s" nur so lange hochgezählt wie der Taster 
gedrückt ist.

[Bit (Gast)]

Im Folgenden findet ihr meine "Organal" Programm es ist noch nicht ganz 
fertig bzw. wird noch erweitert.
Ja da haben sich wirklich ein paar fiese Rechtschreibfehler bei der 
Übertragung eingeschlichen … (Achtung es können sich in den Kommentaren 
immer noch Rechtschreibfehler befinden)
vor allem geht es mir um den teil des Programmes welcher nach
//*****************************taster*********************************** 
*
folgt, da dieser es in dieser Form nicht richtig funktioniert

#define F_CPU 1000000UL

#include <avr/io.h>
#include <avr/interrupt.h>

// definire Bitmuster
#define Zahl0 0b01000000
#define Zahl1 0b01110011
#define Zahl2 0b00100100
#define Zahl3 0b00100001
#define Zahl4 0b00010011
#define Zahl5 0b00001001
#define Zahl6 0b00001000
#define Zahl7 0b01100011
#define Zahl8 0b00000000
#define Zahl9 0b00000001

//     Variablen um Sekunden zu zählen
int s;
//     Variable um Minuten zu Zählen
int m;
//     Variablen um Stunden zu Zählen
int h;
// Variable für das Multiplexen
long int Multiplexen;
//  Variable
int Eingeschaltet = 0;
// Array für die Bittmuster welche angezeigt werden sollen.
char Anzeige[10] = {Zahl0,Zahl1,Zahl2,Zahl3,Zahl4,Zahl5,Zahl6,Zahl7,Zahl8,Zahl9};

//  Array für meine Transistoren welche meine Anzeigen An und Aus schalten
char Transistoren[6] = {PB0,PB1,PB2,PB3,PB4,PB5};

int nummer =0; // variable

int main(void)
{
  // / segment anzeige
  DDRD = 0xff; // DDRD wird zum Ausgang
  PORTD = 0x00; // puldownwiderstände ausgeschaltet
  // Transistoren
  DDRB = 0xff; //DDRB wird zum ausgang
  PORTB = 0xff; // pulldownwiderstände eingeschaltet
  // Taster
  DDRC &= ~(1<<PC0),~(1<<PC1),~(1<<PC2),~(1<<PC3),~(1<<PC4),~(1<<PC5); // wird zum eingang
  PORTC = 0x00; // pulldownwiderstände werden ausgeschaltet
  
  // Festlegung des Taktes auf 1 Hz
  TCCR1B |= (1<<WGM12);
  TIMSK |= (1<<OCIE1A);
  sei(); // erlaube globale interrupts
  OCR1A = 15624; //Preceller von 15624 sorgt für 1  HZ
  TCCR1B |= (1<<CS10) | (1<<CS11); // Teiler
  
  
  while(1)
  {

//*****************************Zähler**************************************
      if (s>59) 
      {
        m++; 
        s=0; 
      }
      if (m>59) 
      {
        h++;  
        m=0; 
      }
      if (h>23) 
      {
        h=0; 
      }
//*****************************Anzeigenzuweisung**************************
      Transistoren [0] = Anzeige[s%10]; 
      Transistoren [1] = Anzeige[s/10]; 
      Transistoren [2] = Anzeige[m%10]; 
      Transistoren [3] = Anzeige[m/10]; 
      Transistoren [4] = Anzeige[h%10]; 
      Transistoren [5] = Anzeige[h/10]; 
//*****************************Multiplexen*******************************
      Multiplexen=0; // Setzt die Variable Multiplexen auf 0 zurück
      PORTB = 0xff; // PORTB wird eingeschaltet
      PORTD = Transistoren[nummer]; 
      PORTB &= ~(1<<nummer);
      nummer++; //Zählt die Variable Index +1
      if (nummer>=6) // wenn die Variable index größer gleich 6 ist wird die schleife ausgeführt
      {
        nummer=0; // Der Variablen wird der Wert 0 gegeben
      }
  }
//*****************************taster************************************  
  // Einschalten ***
  if (PINC & (1<<PC0)==1){ // Pinabfrage von PC0 trift diese zu führe schleife aus
  Eingeschaltet=1;}  // gibt der Variable "Eingeschaltet" den wert 1
  // hier fehlen noch befehle !!!
}   

ISR(TIMER1_COMPA_vect) // Interruptservicerutine
{
//*****************************Sekundenzähler****************************  
  //*** Einschalten ***
  if (Eingeschaltet==1){ // solange die Variable "Eingeschaltet" den wert 1 hatt wird die schleife ausgeführt
  s++;} // variable"s" wird um 1 nach oben gezehlt
}

[Achim S. (Gast)]

Bit schrieb:
> Im Folgenden findet ihr meine "Organal" Programm

prima

Bit schrieb:
> if (PINC & (1<<PC0)==1){ // Pinabfrage von PC0 trift diese zu führe
...

dieser Code kommt nach der Schleife while(1). Da diese Schleife niemals 
beendet wird, wird dieser Code nie ausgeführt, Eingeschaltet bleibt also 
ewig auf 0.

[Peter II (Gast)]

was soll das PB0 usw. darin?

char Transistoren[6] = {PB0,PB1,PB2,PB3,PB4,PB5};
Transistoren [0] = Anzeige[s%10];

[Einer K. (Gast)]

Noch mal den Kommaoperator überprüfen.

// falsch
DDRC &= ~(1<<PC0),~(1<<PC1),~(1<<PC2),~(1<<PC3),~(1<<PC4),~(1<<PC5);

//besser
DDRC &= ~(1<<PC0)&~(1<<PC1)&~(1<<PC2)&~(1<<PC3)&~(1<<PC4)&~(1<<PC5);

oder ganz weg lassen, der Grund wurde schon genannt.


So:
volatile int Eingeschaltet = 0;

if (PINC & (1<<PC0)==1) // ??
if (PINC & (1<<PC0)) // ausreichend

[Dietrich L. (dietrichl)]

Bit schrieb:

> int Eingeschaltet = 0;

Da diese Variable auch in der ISR benutzt wird, braucht Du

volatile int Eingeschaltet = 0;

[eijach (Gast)]

Du musst ggf. die Variablen die im IRQ verwendet werden als "volatile" 
deklarieren.

Sprich "s" und "eingeschaltet" als "volatile int s;"


usw.

[Dorftrottel (Gast)]

Bit schrieb:
> PORTD = 0x00; // puldownwiderstände ausgeschaltet

AVR haben AFAIK Pullup -Widerstände.

[Bit (Gast)]

Achim S. schrieb:

> Bit schrieb:
>> if (PINC & (1<<PC0)==1){ // Pinabfrage von PC0 trift diese zu führe
> ...
>
> dieser Code kommt nach der Schleife while(1). Da diese Schleife niemals
> beendet wird, wird dieser Code nie ausgeführt, Eingeschaltet bleibt also
> ewig auf 0.

Doch diese schleife wird immer wieder ausgeführt da die bedingung gräßer 
0 ist.

Peter II schrieb:
> was soll das PB0 usw. darin?
PB0 usw. sind die bezeichnung meiner pins am yC

> char Transistoren[6] = {PB0,PB1,PB2,PB3,PB4,PB5};
Ein Array mit der bezeichnunt Transistoren

> Transistoren [0] = Anzeige[s%10];
ein Arrey sucht an 0ter stelle etwas und zeigt dieses an
anzeige array sucht die variable die bei der modulation der variable s 
durch 10 herrauskomt und zeigt diese an

Arduino F. schrieb:
> Noch mal den Kommaoperator überprüfen.
>
> // falsch
> DDRC &= ~(1<<PC0),~(1<<PC1),~(1<<PC2),~(1<<PC3),~(1<<PC4),~(1<<PC5);
>
> //besser
> DDRC &= ~(1<<PC0)&~(1<<PC1)&~(1<<PC2)&~(1<<PC3)&~(1<<PC4)&~(1<<PC5);
>
> oder ganz weg lassen, der Grund wurde schon genannt.
>
> So:
> volatile int Eingeschaltet = 0;
>
> if (PINC & (1<<PC0)==1) // ??
> if (PINC & (1<<PC0)) // ausreichend

tatsechnich wen das funktioniert ist es übersichtlicher

eijach schrieb:
> Du musst ggf. die Variablen die im IRQ verwendet werden als
> "volatile"
> deklarieren.
>
> Sprich "s" und "eingeschaltet" als "volatile int s;"
>
> usw.

also gut das werde ich gleich ausprobieren

Dorftrottel schrieb:
> Bit schrieb:
>> PORTD = 0x00; // puldownwiderstände ausgeschaltet
>
> AVR haben AFAIK Pullup -Widerstände.

ok da hatt sich ein bezeichnungsfehler eingeschlichen

Also ich werde das Programm nun umschreibenn und das neue ergebis posten

[Peter II (Gast)]

Bit schrieb:
>> char Transistoren[6] = {PB0,PB1,PB2,PB3,PB4,PB5};
> Ein Array mit der bezeichnunt Transistoren

nein, ganz bestimmt nicht. In dem Array steht einfach die Zahlen 0 bis 5

> Transistoren [0] = Anzeige[s%10];
damit werden die Zahlen eh überschrieben.

[Peter D. (peda)]

Bit schrieb:
> //     Variablen um Stunden zu Zählen
> int h;
> // Variable für das Multiplexen
> long int Multiplexen;

Man muß den RAM nicht mit Gewalt zum Überlaufen bringen.
Mußt Du wirklich -32768..+32767 Stunden zählen?
Und wozu verwendest Du "Multiplexen", daß es von 
-2147483648..+2147483647 zählen muß?

[Rainer U. (r-u)]

Bit schrieb:
> Mein Problem ist nun folgendes, das nichts passiert wenn ich den Taster
> drücke, egal ob lange <1s oder nur kurz >1s.

Mir scheint, Dir fehlt ein wenig Übung im debuggen. Allgemeine 
Techniken:

- LED da umschalten, wo das Programm regelmäßig vorbeikommt (ggf etwas 
bremsen, damit man das blinken noch sehen kann)
- einen Status auf zweiter LED anzeigen
- den Code immer weiter verkürzen (so lange Teile auskommentieren, bis 
es sich / die LEDs sich wie erwartet verhalten)
- danach einzelne Codeabschnitte wieder dazunehmen.

Irgendwann kommt dann immer der Moment, wo man sieht, wie man sich 
selbst ausgetrickst hat.

[Peter D. (peda)]

Man kann solche einfachen Programme aber auch im Simulator laufen lassen 
und sich alles angucken.
Am meisten rächt es sich aber, wenn man vorher keinen Programmablaufplan 
erstellt hat, sondern nur planlos in die Tastatur hackt.

[Bit (Gast)]

Hallo zusammen also ich habe die Fehler nun gefunden

  while(1)
  {

//*****************************Zähler**************************************
      if (s>59) 
      {
        m++; 
        s=0; 
      }
      if (m>59) 
      {
        h++;  
        m=0; 
      }
      if (h>23) 
      {
        h=0; 
      }
//*****************************Anzeigenzuweisung**************************
      Transistoren [0] = Anzeige[s%10]; 
      Transistoren [1] = Anzeige[s/10]; 
      Transistoren [2] = Anzeige[m%10]; 
      Transistoren [3] = Anzeige[m/10]; 
      Transistoren [4] = Anzeige[h%10]; 
      Transistoren [5] = Anzeige[h/10]; 
//*****************************Multiplexen*******************************
      Multiplexen=0; // Setzt die Variable Multiplexen auf 0 zurück
      PORTB = 0xff; // PORTB wird eingeschaltet
      PORTD = Transistoren[nummer]; 
      PORTB &= ~(1<<nummer);
      nummer++; //Zählt die Variable Index +1
      if (nummer>=6) // wenn die Variable index größer gleich 6 ist wird die schleife ausgeführt
      {
        nummer=0; // Der Variablen wird der Wert 0 gegeben
      }
>>>  } 
//*****************************taster************************************  
  // Einschalten ***
  if (PINC & (1<<PC0)==1){ // Pinabfrage von PC0 trift diese zu führe schleife aus
  Eingeschaltet=1;}  // gibt der Variable "Eingeschaltet" den wert 1
  // hier fehlen noch befehle !!!
}   

ISR(TIMER1_COMPA_vect) // Interruptservicerutine
{
//*****************************Sekundenzähler****************************  
  //*** Einschalten ***
  if (Eingeschaltet==1){ // solange die Variable "Eingeschaltet" den wert 1 hatt wird die schleife ausgeführt
  s++;} // variable"s" wird um 1 nach oben gezehlt
}

An dieser Stelle (durch >>> markiert) habe ich meine while(1) Schleife 
geschlossen ich kam also niemals bis zur tasterabfragung.
Fehler Behoben ...

Desweiten habe ich bei der Initialisierung der Variablen nun allen 
Variablen den wert 0 gegeben (ich brauche dort eine 0).
könnt ein fehler gewesen sein ...

Beim Ausmessen der Ausgabe meiner PINC ist mir aufgefallen das PC0 und 
PC1 den selben wert (3) herrausgeben. Daraufhin  habe ich mir mein 
selbergebautes Entwicklungsboard nocheinmal angeschaut und festgestellt 
das ich zwischen PC0 und PC1 eine Lötbrücke hatte.
Lötbrücke entfernt und nun funktioniert wider alles so wie es soll.

Folgende funktionen sind nun möglich:

PC0 -> Startet die Stoppuhr
PC1 -> Stoppt das Programm
PC2 -> setzt das Programm aus 00.00.00 zurück

wenn ich die Stoppuhr gestartet habe (fängt an mit zählen ab 00.00.00 
aufwärtz) und ich mit PC1 Stoppe (z.B. bei 00.12.22) und nun erneut PC0 
drücke leuft die Stoppuhr weiter als hätte ich diese niemals angehalten
Wenn nun die Stoppuhr Läuft und ich PC2 drücke setzt sich die Stoppuhr 
aus 00.00.00 zurück und bleibt dort bis ich diese wider einschalte. (ist 
so gewollt ... momentan)


Peter D. schrieb:
> Man kann solche einfachen Programme aber auch im Simulator laufen
> lassen
> und sich alles angucken.
in der Tat das were eine gute idee gewesen habe das Problem aber auch 
ohne lösen konnen. Trozdem schau ich mich noch nach einem um.

> Am meisten rächt es sich aber, wenn man vorher keinen Programmablaufplan
> erstellt hat, sondern nur planlos in die Tastatur hackt.
nun ich habe sehr wohl einen Programmablaufplan erstellt

Zuletzt möchte ich mich noch bei Allen bedanken die mir bei der Lösung 
meines Problemes geholfen haben

[Achim S. (Gast)]

Bit schrieb:
> Hallo zusammen also ich habe die Fehler nun gefunden
....
Bit schrieb:
> An dieser Stelle (durch >>> markiert) habe ich meine while(1) Schleife
> geschlossen ich kam also niemals bis zur tasterabfragung.
> Fehler Behoben ...

Ja. Und wenn du jetzt folgenden Abschnitt nochmal liest

Achim S. schrieb:
>> if (PINC & (1<<PC0)==1){ // Pinabfrage von PC0 trift diese zu führe
> ...
>
> dieser Code kommt nach der Schleife while(1). Da diese Schleife niemals
> beendet wird, wird dieser Code nie ausgeführt, Eingeschaltet bleibt also
> ewig auf 0.

merkst du, dass genau darauf hingewiesen wurdest :-)

[Bit (Gast)]

Achim S. schrieb:
> Bit schrieb:
>> Hallo zusammen also ich habe die Fehler nun gefunden
> ....
> Bit schrieb:
>> An dieser Stelle (durch >>> markiert) habe ich meine while(1) Schleife
>> geschlossen ich kam also niemals bis zur tasterabfragung.
>> Fehler Behoben ...
>
> Ja. Und wenn du jetzt folgenden Abschnitt nochmal liest
>
> Achim S. schrieb:
>>> if (PINC & (1<<PC0)==1){ // Pinabfrage von PC0 trift diese zu führe
>> ...
>>
>> dieser Code kommt nach der Schleife while(1). Da diese Schleife niemals
>> beendet wird, wird dieser Code nie ausgeführt, Eingeschaltet bleibt also
>> ewig auf 0.
>
> merkst du, dass genau darauf hingewiesen wurdest :-)

Ja durch diesen Post bin ich überhaupt darauf gestoßen ^^ ohne würde ich 
warscheinlich immernoch suchen ...
ich wollte in meinem letzten Beitrag nur auf die gravierendsten Fehler 
in meinem programm hinweisen.

[Bit (Gast)]

Und der Hardware...