Anfängerhilfe bei Input

[Martin *. (mistermister606)]

Hallo zusammen ich habe vor wenigen Tagen mit dem rumpus board zu 
programmieren begonnen. Jetzt komme ich allerdings trotz des 
AVR-GCC-Tutorial nicht weiter.

Ich möchte einen Eingang (schalter) einlesen und dementsprechend eine 
LED leuchten lassen.


DANKE

//io.h einbinden damit die ARV Register ueber Namen wie DDRD angesprochen werden koennen
#include <avr/io.h>
//delay.h einbinden damit die Funktion _delay_loop_2 bekannt ist
#include <util/delay.h>


void main(void) {

DDRD = (1<<PD3) | (1<<PD6);
DDRC &= ~(1<<PC0);  // Definition des Eingangs      = 0 = Eingang
PORTC |= (1<<PC0);  // Pul Up       = EIN




if ( PINC & (1<<PINC0) ) {

PORTD |= (1<<PD3);  //LED2
}



if ( !(PINC & (1<<PINC0)) ) {

  PORTD |= (1<<PD6);  //LED3
}

 
   while(1) {                // (5)
    }                         // (7)
   return 0;                 // (8)



}

[Karl H. (kbuchegg)]

Fang erst mal damit an, deinem Programm eine vernünftige äussere Form zu 
geben. Interessanterweise haben nämlich die mit den scheuslichsten 
Programmen immer wieder das Problem, dass
* sie ihre eigenen Programme nicht verstehen
* sie die tollsten und unlogischten Fehler haben


Jedes C-Programm, dass du in den nächsten Wochen schreiben wirst, folgt 
immer diesem grundsätzlichen Aufbau

#include ....


int main()
{
  Initialisierungen. Das beinhaltet
  * Variablen auf Startwerte stellen
  * Die Hardware-Sachen konfigurieren


  eventuell ein sei(), wenn im Programm mit Interrupts gearbeitet wird

  while( 1 )
  {
    hier kommt die eigentliche Programmarbeit rein
    also das was das Programm tun soll
  }
}

Die 'eigentliche Arbeit' die dein Programm machen soll, besteht darin 
die LED je nach Schalterstellung entsprechen ein oder auszuschalten.

Und jetzt formatier erst mal dein Programm richtig und sieh nach, wo und 
wie du die Dinge angeordnet hast.

[Kali (Gast)]

Wenns VHDL wäre würd's vielleicht gehen. ;-)

[Karl H. (kbuchegg)]

Zum Thema formatieren
* eine einzige Leerzeile zwischen funktionalen Blöcken ist ok.
  Die Leerzeile sorgt für eine optische Gruppierung und leitet
  dich beim Lesen. Sie sagt dir: hier ist ein Gedankengang zu Ende
  und eine neuer Gedanke beginnt.

  Das macht EINE Leerzeile.

  Viele Leerzeilen hintereinander hingegen bringen nichts. Sie ziehen
  den Code nur in die Länge und bewirken das Gegenteil. Die Übersicht
  steigt nicht, sondern sie nimmt ab. Eben weil der Code unnötigerweise
  in die Länge gezogen wird.

* nach jeder öffnenden Klammer { beginnt ein neuer sog. Code-Block.
  um den Code-Block erkennen zu können ohne jedesmal die
  einschliessenden { } suchen zu müssen, wird der Block eingerückt.
  Nach einer { wird der zum Block gehörende Code um 2 Leerzeichen
  eingerückt. Diese Einrückung wird erst wieder mit der schliessenden }
  wieder aufgehoben. Die schliessende } steht auf der selben
  Einrücktiefe wie entweder die { selber oder wie die Anweisung in der
  die { zu finden ist. Auf die Art braucht man nur immer einfach nur
  in derselben Spalte nach oben oder nach unten im Code zu gehen um
  die jeweils korrespondierende { oder } zu finden und zu sehen, welchen
  Code die { } in einen Codeblock einschliessen.

Die erste Einrückversion sieht so aus

int main()
{
  // einrücken

  ...

  while( 1 )
  {
    // einrücken

    if( PIND & ( 1 << PD2 ) )
    {
      // einrücken
      PORTB = 5;
      // Block ist zu Ende, also für die } ausrücken
    }
    else
    {
      // einrücken
      PORTB = 8;
      // ausrücken
    }

    // Block zu Ende, es fehlt noch eine } für das while
    // also ausrücken
  }

  // und es fehlt noch ein } für die { nach dem int main()
}

die andere Version sieht so aus (jetzt ohne die blödsinnigen 
einrücken/ausrücken Kommentare. Die schreibt man natürlich nicht 
wirklich)

int main()
{
  ...

  while( 1 ) {

    if( PIND & ( 1 << PD2 ) ) {
      PORTB = 5;
    }
    else {
      PORTB = 8;
    }
  }
}

Die Variante, in der die öffnende { auf derselben Zeile steht (mit 
Ausnahme nach einem Funktionskopf) ist etwas platzsparender als die 
Variante, in der die { ihre eigene Zeile bekommt. Aber ansonsten sind 
die Dinge gleichwertig: Nach einem { wird eingerückt. Die schliessende } 
wird wieder ausgerückt.

Am Ende einer Funktion muss die schliessende } wieder am linken Rand 
stehen. Sonst stimmt irgendwo mit den { und } etwas nicht.

Aber auf keinen Fall kann es sein, dass eine Anweisung am linken Rand 
anfängt.

[Martin *. (mistermister606)]

Erstmal vielen vielen DANK.
Ich habe nun alles etwas aufgeräumt und siehe da dann auch den Fehler 
verstanden :)
Ich finde genau diesen letzten Artikel TOP, packe doch den gleich mal 
ins AVR-GCC-Tutorial den dies würde viele Anfänger vor genau solchen 
Fehlern bewahren!
Hab ich noch etwas übersehen oder ist die äußere Form, für meine 
nächsten Schritte ok ? :)

#include <avr/io.h>
#include <util/delay.h>


int main()
{

  DDRD = (1<<PD3) | (1<<PD6);
  DDRC &= ~(1<<PC0);  // Definition des Eingangs    = 0 = Eingang
  PORTC |= (1<<PC0);  // Pul Up         = EIN
  PINC &= ~(1<<PC0);  // Ausgangszustand      = 0


  while( 1 )
  {
    
    if ( PINC & (1<<PINC0) ) {
      PORTD |= (1<<PD3);  //LED2
      PORTD &= ~(1<<PD6);  //LED3 reset
    }

    if ( !(PINC & (1<<PINC0)) ) {
      PORTD |= (1<<PD6);  //LED3
      PORTD &= ~(1<<PD3);  //LED2 reset
    }

  }
}

[Karl H. (kbuchegg)]

Martin *** schrieb:
> Erstmal vielen vielen DANK.
> Ich habe nun alles etwas aufgeräumt und siehe da dann auch den Fehler
> verstanden :)

gut. das war der Sinn der Sache.


> Hab ich noch etwas übersehen oder ist die äußere Form, für meine
> nächsten Schritte ok ? :)

Ist soweit ok.


Hier

>     if ( PINC & (1<<PINC0) ) {
>       PORTD |= (1<<PD3);  //LED2
>       PORTD &= ~(1<<PD6);  //LED3 reset
>     }
>
>     if ( !(PINC & (1<<PINC0)) ) {
>       PORTD |= (1<<PD6);  //LED3
>       PORTD &= ~(1<<PD3);  //LED2 reset
>     }

gibt es noch was.

Die Bedingung vom 2.ten if ist das genau Gegenteil der Bedingung vom 
1.ten if. Ist ja auch logisch warum das so sein soll.

Schreib das besser mit einem else

     if ( PINC & (1<<PINC0) ) {
       PORTD |= (1<<PD3);  //LED2
       PORTD &= ~(1<<PD6);  //LED3 reset
     }
     else {
       PORTD |= (1<<PD6);  //LED3
       PORTD &= ~(1<<PD3);  //LED2 reset
     }

das hat gleich mehrere Vorteile
* zum einen verhindert es blöde Tippfehler in den Bedingungen. Alles was
  man 2 mal tippen muss, öffnet schon die Gefahr dass man sich einmal
  vertippt.

* zum anderen bindet es die beiden abhängigen Code-Blöcke enger 
aneinander. Ich muss nicht erst lange die beiden if-Bedingungen 
studieren um mich zu vergewissern, dass die eine das Gegenteil vom 
anderen ist und dass diese beiden Code Blöcke voneinander abhängen und 
zwischen ihnen eine Beziehung besteht. Das else erzählt es mir mit einem 
Blick.

* Es entspricht auch (in diesem Fall) etwas besser unserer menschlichen 
Denkweise. Wir sagen: Wenn die Taste gedrückt ist, dann schalte die LED 
ein, anderfalls schalte sie aus.
Wir sagen nicht: Wenn die Taste A gedrückt ist, dann schalte die LED 
ein. Wenn die Taste A nicht gedrückt ist, dann schalte die LED aus.
Auch hier wieder: Die erste Version ist uns vertrauter, weil sie in der 
Formulierung kürzer ist und weil sie einen expliziten Bezug zwischen 
"Wenn .. andernfalls ..." herstellt. Im zweiten Fall musst du beim Lesen 
des zweiten Teilsatzes kurz im Text zurückgehen um festzustellen: 
Hoppla, da ist ja von derselben Taste die Rede.

[Martin *. (mistermister606)]

nochmals DANKE :) thumbsup