Übertragung von High- und Low-Signalen zwischen zwei AVR

[Chris K. (ati13)]

Hallo,

ich möchte gerne High- bzw. Low-Pegel von einem AVR zu einem anderen 
übertragen. Leider habe ich Probleme mit der Realisierung. Beide 
Programme (Ausgabe der "einsen" bzw. "nullen" auf der einen Seite, 
einlesen der "einsen" mit Hilfe von Tastern und Pull-Ups auf der 
anderen) hab ich natürlich bereits einzeln getestet. -> Fehler in den 
Programmen sind ausgeschlossen, es muss an der Beschaltung oder 
ähnlichem liegen.
Bis jetzt habe ich einfach Aus- und Eingänge der AVR direkt verbunden, 
beide Massen ebenfalls. Die internen Pull-Ups habe ich nicht aktiviert, 
weil ja theoretisch zu jedem Zeitpunkt ein definierter Zustand an den 
Eingangspins anliegen sollte (richtig?).
Wo liegt also der (Denk-) Fehler?

Vorab schonmal danke!
Chris

[Max H. (hartl192)]

Chris K. schrieb:
> es muss an der Beschaltung oder
> ähnlichem liegen.
Dann zeig uns die mal, am besten zusammen mit dem Quellcode.

[spess53 (Gast)]

Hi

>Wo liegt also der (Denk-) Fehler?

da

>Fehler in den Programmen sind ausgeschlossen, ...

MfG Spess

[Kaj (Gast)]

Chris K. schrieb:
> Fehler in den
> Programmen sind ausgeschlossen,
Warum faehrt das Auto nicht mehr?
Am Benzin kann's jeden falls nicht liegen, is naemlich keins drin.

[Chris K. (ati13)]

Ist ja gut, wenn's sein muss poste ich den Code...
Vorher möchte ich aber meine eigentliche Frage beantwortet haben.
(-> siehe Schaltung)
Es geht mir nur um's Prinzip! Also:
Wenn ich dem AVR1 sage

portB = 0b00001111; // PortB, Pin0..3 auf "1"setzen

und beim AVR2 abfrage

if(portB = 0b00001111){/*mach was*/} // Signale an PortB, Pin0..3 abfragen

...würde dies so funktionieren (mit dieser Art von Schaltung) oder 
müsste ich etwas verändern?

Falls ihr mir noch nicht richtig folgen könnt oder den Fehler im 
Programm vermutet, kann ich auch den kompletten Code posten. (der aber 
recht umfangreich ist...)

PS: Die Abfrage gestalte ich in Wirklichkeit etwas anders, k.A. ob die 
Beispiel-Syntax so stimmt oder nicht. Es geht nur um's Prinzip!

[asterix (Gast)]

es geht im Prinzip also nur ums Prinzip...

-das ist kein Schaltplan, höchstens eine Skizze
-deine Quellcode ist zu groß? Dann minimiere diesen
-die Abfrage gestaltest du anders als beschrieben? ja wie denn nun

so wirst du nie brauchbare Antworten bekommen ! ;-)


um deiner sperrlichen Frage eine sperrliche Antwort zu liefern: Ja, so 
etwas kann funktionieren

[Falk B. (falk)]

@ Chris K. (ati13)

>if(portB = 0b00001111){/*mach was*/} // Signale an PortB, Pin0..3 abfragen

FALSCH! Eher so

if(PINB = 0b00001111){/*mach was*/} // Signale an PortB, Pin0..3 
abfragen


>PS: Die Abfrage gestalte ich in Wirklichkeit etwas anders, k.A. ob die
>Beispiel-Syntax so stimmt oder nicht. Es geht nur um's Prinzip!

Eben DARUM soll man IMMER originalen Code posten und keine 
zuzammengetippten Codefetzen!

Siehe

http://www.mikrocontroller.net/articles/Netiquette#Klare_Beschreibung_des_Problems

[Max H. (hartl192)]

> if(portB = 0b00001111){/*mach was*/}
Das ist unabhängig von PortB immer True, siehe = vs. ==
Zum Abfragen von Eigängen nimmt man PINB

[uwe (Gast)]

> FALSCH! Eher so
>
> if(PINB = 0b00001111){/*mach was*/} // Signale an PortB, Pin0..3
Eher so
  if(PINB == 0b00001111){/*mach was*/} // Signale an PortB, Pin0..3

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Chris K. schrieb:
> und beim AVR2 abfrage

if(portB = 0b00001111){/*mach was*/} // Signale 
> an PortB, Pin0..3 abfragen

> ...würde dies so funktionieren (mit dieser Art von Schaltung) oder
> müsste ich etwas verändern?

Es ist beeindruckend, dass Du es geschafft hast, in dieser einen 
Programmzeile mindestens drei schwere Programmierfehler zu machen. Und 
bei derart schwachen Programmierkenntnissen auch noch zu behaupten, das 
eigentliche Programm sei fehlerfrei, ist schon reichlich vermessen.

Und die Initialisierung Deiner Ports in Sende- und Empfangsrichtung 
verheimlichst Du auch.

Warum soll man sich hier also damit abgeben, auf solchen hingerotzten 
Dreck auch noch inhaltlich einzugehen?

[Falk B. (falk)]

@ uwe (Gast)

>Eher so
>  if(PINB == 0b00001111){/*mach was*/} // Signale an PortB, Pin0..3

Uuups. ;-)

Naja, wenn schon, dann WIRKLICH richtig, mit Bitmanipulation.

[Chris K. (ati13)]

@ asterix

Dann ist es eben eine Skizze...diese zeigt aber eben genau mein Problem 
(nicht mehr und nicht weniger): kommen die Einsen und Nullen, die AVR1 
ausgibt überhaupt am AVR2 an, wenn ich einfach die entsprechenden Pins 
(und beide Massen) verbinde?

@ falk

Oh, da habe ich mich vertan, ich meinte eigentlich: if (PINB = ...)...

...der Code mit ausführlicher Kommentierung folgt dann demnächst ;-)

[uwe (Gast)]

> Oh, da habe ich mich vertan, ich meinte eigentlich: if (PINB = ...)...
nein du meintest if (PINB == ...)...

[uwe (Gast)]

Also wenn du es geschafft hast in einer Codezeile 2 Fehler zu machen und 
ich dein Programm jetz auf 20 Zeilen schätze, dann komme ich auf 40 
weitere Fehler.

[Route_66 H. (route_66)]

Falk Brunner schrieb:
> @ uwe (Gast)
>
>>Eher so
>>  if(PINB == 0b00001111){/*mach was*/} // Signale an PortB, Pin0..3
>
> Uuups. ;-)
>
> Naja, wenn schon, dann WIRKLICH richtig, mit Bitmanipulation.

Da er nicht geschrieben hat, was seine Programmiersprache ist, z.B. bei 
Bascom oder Luna, könnte das einfache "=" sogar schon richtig sein.

[Falk B. (falk)]

@Chris K. (ati13)

>(nicht mehr und nicht weniger): kommen die Einsen und Nullen, die AVR1
>ausgibt überhaupt am AVR2 an, wenn ich einfach die entsprechenden Pins
>(und beide Massen) verbinde?

Natürlich. Das ist elementarste E-Technik.

>Oh, da habe ich mich vertan, ich meinte eigentlich: if (PINB = ...)...

Du kennst den Unterschied zwischen = und == in C?

[Chris K. (ati13)]

@ uwe

Richtig.

@ schweigstill

Wieso kommentierst du überaubt diesen Thread, wenn du mir eigentlich 
sowieso nicht helfen willst? Das ist doch nur verschwendete Zeit oder? 
Dann lass es doch einfach gleich bleiben...
Und wenn du mir nicht glaubst, dass es einzeln funktioniert hat, kann 
ich dir auch nicht helfen. Den Code-Auzug habe ich frei erfunden, um zu 
verdeutlichen, was mein Problem ist. Er kommt so nicht im Programm vor.

Wie gesagt, das vollständige Programm folgt demnächst...

[spess53 (Gast)]

Hi

>Dann ist es eben eine Skizze...diese zeigt aber eben genau mein Problem
>(nicht mehr und nicht weniger): kommen die Einsen und Nullen, die AVR1
>ausgibt überhaupt am AVR2 an, wenn ich einfach die entsprechenden Pins
>(und beide Massen) verbinde?

Wenn die Datenrichtungsregister stimmen kommen die klar an. Allerdings 
würde ich mir Gedanken über Handshake-Signale machen. Dann weiß der 
Empfänger wann ein neues Signal anliegt und der Sender, wenn das Signal 
abgeholt/verarbeitet ist.

MfG Spess

[Chris K. (ati13)]

@ falk

Ja, den kenne ich. C++ kommt Java ja syntaktisch ziemlich nahe. Und nach 
zwei Semestern Java sollte man solch eine elemtare Angelegenheit so 
langsam beherrschen können oder? ;-)

[MiWi (Gast)]

Chris K. schrieb:
> @ uwe
>
> Richtig.
>
> @ schweigstill
>
> Wieso kommentierst du überaubt diesen Thread, wenn du mir eigentlich
> sowieso nicht helfen willst? Das ist doch nur verschwendete Zeit oder?
> Dann lass es doch einfach gleich bleiben...
> Und wenn du mir nicht glaubst, dass es einzeln funktioniert hat, kann
> ich dir auch nicht helfen. Den Code-Auzug habe ich frei erfunden, um zu
> verdeutlichen, was mein Problem ist. Er kommt so nicht im Programm vor.
>

Wenn DU hier Fragen stellst dann denk daran, daß andere dafür ihre 
Zeit aufwenden DIR zu antworten ohne Dir eine Rechnung zu stellen.

Stelle die Fragen also so, daß sie auch - mit aller (In)kompetenz - den 
aktuellen Zustand beschreiben und dokumentieren.

Schaltpläne, die nicht der Realität entsprechen und Code, der so nicht 
vorhanden ist.... ist gelinde gesagt eine Zumutung. Also rotz hier nicht 
so herum.

Grüße

MiWi

[Frank M. (ukw) (Moderator)]

Chris K. schrieb:
> Ist ja gut, wenn's sein muss poste ich den Code...

Ja, vorher hat das keinen Sinn. Es muss ja nicht das komplette Projekt 
sein. Wenn Du den Fehler auf ein Minimal-Programm reduzieren kannst, 
wirds einfacher, den Fehler zu finden.

Ich frage mich nur, wie Du das Handshake zwischen den beiden AVRs 
machst...

> Vorher möchte ich aber meine eigentliche Frage beantwortet haben.
> (-> siehe Schaltung)

In der Schaltung fehlen zumindest die Abblockkondensatoren und evtl. 
auch noch eine korrekte Reset-Beschaltung.

Wie lang sind die Kabel zwischen den beiden AVRs? 100 Meter oder 2 cm?

[0815 (Gast)]

Chris K. schrieb:
> Und wenn du mir nicht glaubst, dass es einzeln funktioniert hat, kann
> ich dir auch nicht helfen. Den Code-Auzug habe ich frei erfunden, um zu
> verdeutlichen, was mein Problem ist. Er kommt so nicht im Programm vor.

Mit derartig getürkten und falschen Infos schaffst du dir hier keine 
Freunde.

[Karl H. (kbuchegg)]

Chris K. schrieb:

> Den Code-Auzug habe ich frei erfunden, um zu
> verdeutlichen, was mein Problem ist. Er kommt so nicht im Programm vor.

Anfrage an Radio Eriwan:
Stimmt es, dass Iwan Iwanowitsch in der Lotterie ein rotes Auto gewonnen 
hat?
Antwort:
Im Prinzip ja.
Aber es war nicht Iwan Iwanowitsch, sondern Pjotr Petrowitsch.
Und es war kein Auto, sondern ein Fahrrad.
Und er hat es nicht gewonnen, sondern es ist ihm gestohlen worden.
Aber sonst stimmt alles.

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Chris K. schrieb:
> Und wenn du mir nicht glaubst, dass es einzeln funktioniert hat,

Du hast nicht behauptet, dass das Programm einzeln funktioniert habe, 
sondern dass das Programm fehlerfrei sei:

> Fehler in den Programmen sind ausgeschlossen, ...

Das sind völlig unterschiedliche Aussagen, die kaum etwas gemeinsam 
haben. Ich habe auch nie behauptet, Dir nicht zu glauben, dass Dein 
Programm in dem von Dir getesteten Kontext funktioniert hätte.

Bevor Du hier also solche haarsträubenden Behauptungen zur 
Fehlerfreiheit aufstellst, solltest Du Dich erst einmal mehrere Jahre 
mit den Grundlagen der Testbarkeit von Software und Elektronik befasst 
haben.

[Chris K. (ati13)]

@ MiWi
>Warum soll man sich hier also damit abgeben, auf solchen hingerotzten
>Dreck auch noch inhaltlich einzugehen?
(Zitat von schweigstill)

Ich hab jetzt nach diversen Beiträgen, die sich inhaltlich sehr ähneln 
begriffen, dass ich mein Problem ausführlicher schildern soll.
Aber solche besch...eidenen Beiträge (siehe Zitat) könnt ihr euch 
wirklich sparen! Ich wollte mein Anliegen doch einfach nur auf ein 
Minimum reduzieren. Anscheinend ist das so in Foren nicht üblich, weil 
man die Kenntnisse und Fähigkeiten der anderen nicht kennt.
Gut. Das hab ich nun verstanden und poste die wichtigsten Details meines 
Projektes/Programmes:

Zum Projekt allgemein:
Ich möchte damit eine 4-stufige Treppe effektvoll mit LED-Streifen 
beleuchten. Jeder der 4 Streifen soll einzeln vom µC angesteuert werden 
können, sodass gewisse Muster (z.B. Lauflicht) entstehen können. Im Code 
entspricht "Modus" dem auszugebenen Muster.

Teil1:
Dieser µC soll die Stellungen zweier Potis ermitteln und die Werte 
entsprechend quantisieren. Danach sollen insgesamt 2 3-bit-Werte am 
PortB ausgegeben werden. Die Leitung zum anderen Controller beträgt 
übrigens ca. 15-20m.

class Application : public Controller
{
    // Bausteine und Attribute .........................................
    protected: unsigned int moduswahl, g_wert, geschwindigkeit;
    protected: AdcMultiChannel potentiometer; // Klasse der Objekt-Biblioth. von SySi (myAVR)
    
    // Funktionen ......................................................
    public: void onStart()
    {
        // Pin-Konfigurationen 
        ddrB.bit0=1; //
        ddrB.bit1=1; // Modus
        ddrB.bit2=1; //
        ddrB.bit3=1;   //
        ddrB.bit4=1;   // Geschwindigkeit
        ddrB.bit5=1;   // 
        
        // Objekt konfigurieren
        potentiometer.config();    
        potentiometer.addChannel(0); // ADC-Kanal 0 
        potentiometer.addChannel(1); // ADC-Kanal 1 
        potentiometer.configInt();
        
        // Attribute
        moduswahl=0;
        g_wert=0;       
    } 
       
    public: void onWork()
    {       
        moduswahl = potentiometer.getValue10(0); // 10 bit-Wert vom Kanal 0 einlesen  
        
        // Bits 0 bis 2 sind für die Übergabe des Modus' gedacht
        if (moduswahl <= 200){
          portB = 0b00000000;  // alles aus (Geschw. egal)    
        } 
        else if ((moduswahl > 200) & (moduswahl <= 400)){
          portB = 0b00000001;  // alles an (Geschw. egal)
        }
      else if ((moduswahl > 400) & (moduswahl <= 600)){
          portB = (0b00000010 + geschw_ermitteln());  // Lauftlicht nach unten
        }
        else if ((moduswahl > 600) & (moduswahl <= 800)){ 
          portB = (0b00000011 + geschw_ermitteln());  // Lauflicht nach oben
      } 
      else if ((moduswahl > 800) & (moduswahl <= 1024)){ 
          portB = (0b00000100 + geschw_ermitteln());  // blinken
      }      
    } 
    
    public: int geschw_ermitteln() 
    {
    g_wert = potentiometer.getValue10(1); // 10 bit-Wert vom Kanal 1 einlesen
        
        // Bits 3 bis 5 stellen den Wert der Geschwindigkeit dar
        if (g_wert <= 128){
          geschwindigkeit = 0b00000000;
        } else if ((g_wert > 128) & (g_wert <= 256)){
          geschwindigkeit = 0b00001000;  
        } else if ((g_wert > 256) & (g_wert <= 384)){
          geschwindigkeit = 0b00010000;
        } else if ((g_wert > 384) & (g_wert <= 512)){ 
          geschwindigkeit = 0b00011000;
        } else if ((g_wert > 512) & (g_wert <= 640)){
          geschwindigkeit = 0b00100000;
        } else if ((g_wert > 640) & (g_wert <= 768)){
          geschwindigkeit = 0b00101000;
        } else if ((g_wert > 768) & (g_wert <= 896)){
          geschwindigkeit = 0b00110000;
        } else if ((g_wert > 896) & (g_wert <= 1024)){
          geschwindigkeit = 0b00111000;
        }

         return geschwindigkeit;
    }      
        
} app;  // Anwendungsinstanz

Teil2:
Dieser µC soll regelmäßig (alle 100ms, siehe Code) die Eingangszustände 
am PortD einlesen. Dies sind die Zustände, die vom anderen Controller 
erzeugt oder angelegt werden. Je nach Modus werden verschiedene 
Prozeduren abgearbeitet. Ändert sich die Geschwindigkeit, wird dies im 
jeweiligen Unterprogramm registriert. Ändert sich der Modus, wird das 
Unterprogramm verlassen und es wird im Hauptprogramm der aktuelle Modus 
abgefragt.

class Application : public Controller
{
    // Bausteine und Attribute .........................................
    protected: unsigned char modus;
    protected: unsigned int geschwindigkeit;
    
    // Funktionen ......................................................
    public: void onStart()
    {
        // Pin-Konfigurationen 
        ddrD.bit2=0;  //
        ddrD.bit3=0;  // Modus 
        ddrD.bit4=0;  //
        ddrD.bit5=0;    //
        ddrD.bit6=0;    // Geschwindigkeit 
        ddrD.bit7=0;    //
        
        ddrB.bit0=1; //
        ddrB.bit1=1; // Stufen
        ddrB.bit2=1; //
        ddrB.bit3=1; //
         
        modus_lesen(); // beim Start einmal den Modus
        geschw_lesen(); // und die Geschwindigk. einlesen
        
    }
    
    public: void onWork()
    {        
        switch (modus)  // Modus abfragen und entsprechende Muster ausgeben
        {
        case 0 : 
          portB = 0b00000000;  // alle Stufen aus
          break;
       case 1 :
          portB = 0b00001111; // alle Stufen an
          break;
       case 2 :
         lauflicht_voll(0); // 0 - nach unten
         break;
       case 3 :
         lauflicht_voll(1); // 1 - nach oben
         break;
       case 4 :
         blinken();  // blinken
         break;
       default :
         portB = 0b00000000;  // sonst alle aus
        }
        
    }
    
    void lauflicht_voll(char richtung)
    {
      if (richtung == 0){  // nach unten
        while (modus == 2){
                ...
                }
        if (richtung == 1){  // nach oben
        while (modus == 3){
                ...
                }
    }
    
    void blinken()
    {
      ...
    } 
    
    void modus_lesen()
    {
      if ((pinD.bit2 == 0) & (pinD.bit3 == 0) & (pinD.bit4 == 0)){ 
        modus = 0;
      } else if ((pinD.bit2 == 1) & (pinD.bit3 == 0) & (pinD.bit4 == 0)){
        modus = 1;
      } else if ((pinD.bit2 == 0) & (pinD.bit3 == 1) & (pinD.bit4 == 0)){
        modus = 2;
      } else if ((pinD.bit2 == 1) & (pinD.bit3 == 1) & (pinD.bit4 == 0)){
        modus = 3;
      } else if ((pinD.bit2 == 0) & (pinD.bit3 == 0) & (pinD.bit4 == 1)){
        modus = 4;
      }
    }  
    
    void geschw_lesen()
    {
      if ((pinD.bit5 == 0) & (pinD.bit6 == 0) & (pinD.bit7 == 0)){
        geschw = 1100;
      } else if ((pinD.bit5 == 1) & (pinD.bit6 == 0) & (pinD.bit7 == 0)){
        geschw = 950;
      } else if ((pinD.bit5 == 0) & (pinD.bit6 == 1) & (pinD.bit7 == 0)){
        geschw = 800;
      } else if ((pinD.bit5 == 1) & (pinD.bit6 == 1) & (pinD.bit7 == 0)){
        geschw = 650;
      } else if ((pinD.bit5 == 0) & (pinD.bit6 == 0) & (pinD.bit7 == 1)){
        geschw = 500;
      } else if ((pinD.bit5 == 1) & (pinD.bit6 == 0) & (pinD.bit7 == 1)){
        geschw = 350;
      } else if ((pinD.bit5 == 0) & (pinD.bit6 == 1) & (pinD.bit7 == 1)){
        geschw = 200;
      } else if ((pinD.bit5 == 1) & (pinD.bit6 == 1) & (pinD.bit7 == 1)){
        geschw = 50;
      }    
    }
    
    void onTimer100ms()  // regelmäßige Abfrage der Eingangswerte 
    {  
      modus_lesen();
      geschw_lesen();
    }
    
} app;  // Anwendungsinstanz

Falls es Fragen gibt, raus damit!

[Chris K. (ati13)]

@ schweigstill

>Beide Programme (Ausgabe der "einsen" bzw. "nullen" auf der einen Seite,
>einlesen der "einsen" mit Hilfe von Tastern und Pull-Ups auf der
>anderen) hab ich natürlich bereits einzeln getestet. -> Fehler in den
>Programmen sind ausgeschlossen

Dass ich beide Programmteile bereits einzeln getestet habe, hatte ich 
schon erwähnt...das hast du vielleicht überlesen. Aber ist jetzt auch 
egal.

[Jonas B. (jibi)]

> void geschw_lesen()
>    {
>      if ((pinD.bit5 == 0) & (pinD.bit6 == 0) & (pinD.bit7 == 0)){
>        geschw = 1100;
>      } else if ((pinD.bit5 == 1) & (pinD.bit6 == 0) & (pinD.bit7 == 0)){
>        geschw = 950;
>....

Muhaha. Was ein Murks......

[Karl H. (kbuchegg)]

Chris K. schrieb:

Das ist doch dieses "Sisy" oder wie das heisst

>     void onTimer100ms()  // regelmäßige Abfrage der Eingangswerte
>     {
>       modus_lesen();
>       geschw_lesen();
>     }

Und der Timer läuft einfacgh so? Da muss nichts konfiguriert werden?

Zum Rest: Poah, eh. Selten so "komplizierten" Code gesehen, weil man den 
Zusammenhang zwischen Bits und den sich daraus ergebenden Zahlen nicht 
verstanden hat.

[Chris K. (ati13)]

@ jibi

Ja, da gibt es sicher noch elegantere Lösungen, mir fiel spontan keine 
ein... ich möchte (darf) eben nicht den gesamten "PinD" abfragen, 
sondern will nur 3 bits prüfen.
Wie könnte man das machen?

[m-obi (Gast)]

modus = (pinD >> 2) && 0x07;

[Jonas B. (jibi)]

>Zum Rest: Poah, eh. Selten so "komplizierten" Code gesehen, weil man den
>Zusammenhang zwischen Bits und den sich daraus ergebenden Zahlen nicht
>verstanden hat.

Ne der macht kein Sinn:

Beispiel die Funktion "geschw_lesen"

Er moechte wohl in Abhängigkeit von den bits 5,6,7 die geschwindigkeit 
übermitteln. Statt die drei bits in ein byte zu schieben und das mit 150 
zu multiplizieren wäre wohl zu einfach.

Also diese bitorgie die auch noch fehler enthält:

000
100
010
110
001
101
011
111

Man o man...................

Gruß JOnas

[Karl H. (kbuchegg)]

Das ist doch C++ Code in einer Umgebung verpackt.
Oder irre ich mich?

Denn in C++ ist das hier

      if ((pinD.bit2 == 0) & (pinD.bit3 == 0) & (pinD.bit4 == 0)){

an dieser Stelle nicht richtig.
Ein & ist ein binäres Und. Du willst hier aber ein logisches Und haben. 
Das schreibt sich aber als &&


Abgesehen davon. Kannst du denn nicht auf den Port als Ganzes zugreifen?

Der ganze Code hier

    void modus_lesen()
    {
      if ((pinD.bit2 == 0) & (pinD.bit3 == 0) & (pinD.bit4 == 0)){ 
        modus = 0;
      } else if ((pinD.bit2 == 1) & (pinD.bit3 == 0) & (pinD.bit4 == 0)){
        modus = 1;
      } else if ((pinD.bit2 == 0) & (pinD.bit3 == 1) & (pinD.bit4 == 0)){
        modus = 2;
      } else if ((pinD.bit2 == 1) & (pinD.bit3 == 1) & (pinD.bit4 == 0)){
        modus = 3;
      } else if ((pinD.bit2 == 0) & (pinD.bit3 == 0) & (pinD.bit4 == 1)){
        modus = 4;
      }
    }

reduziert sich dann zu

    void modus_lesen()
    {
      unsigned char mod = ( PIND >> 2 ) & 0x07;
      if( mod < 5 )
        modus = mod;
    }

(für PIND dann eben das Sprachmittel einsetzen, mit dem du auf den Port 
als ganzes zugreifen kannst)

und mit der Geschwindigkeit kann man ähnliches machen. Und beim Senden 
genau das gleiche, etc. etc.
Manchmal ist es nicht klug alles auf einzelne Bits an einem Port 
runterzubrechen. Das bläht den Code nur ungemein auf und wie man sieht 
steigt damit auch die Fehlerwahrscheinlichkeit. Manchmal ist es viel 
einfacher den Port als ganzes einzulesen und dann einfach gezielt die 
Bits, die man nicht haben will, auf 0 zu setzen oder ein wenig zurecht 
zu schieben, bis sie an den gewünschten Positionen sind.

soviel zum Thema
> Fehler in den Programmen sind ausgeschlossen

[C-Progger (Gast)]

Chris K. schrieb:
> Dass ich beide Programmteile bereits einzeln getestet habe, hatte ich
> schon erwähnt...das hast du vielleicht überlesen. Aber ist jetzt auch
> egal.

Dann kannst Du froh sein, daß Dein Compiler Code erzeugt, der halbwegs 
funktioniert....:

Chris K. schrieb:
> void geschw_lesen()
>     {
>       if ((pinD.bit5 == 0) & (pinD.bit6 == 0) & (pinD.bit7 == 0)){
>         geschw = 1100;
>       } else if ((pinD.bit5 == 1) & (pinD.bit6 == 0) & (pinD.bit7 ==
> ......

Willst Du hier wirklich bitweise verunden ("=") oder Bedinungen abtesten 
("==")?
 Überleg es Dir, lies das C-Tutorial und schau Dir Deinen Code nochmal 
an....

[C-Progger (Gast)]

m-obi schrieb:
> modus = (pinD >> 2) && 0x07;

... das ist keinen Deut besser :'(

[Jonas B. (jibi)]

Im übrigen logische und binäre Operationen unterscheiden sich!

a & b ist nicht das gleiche wie a && b
Gruß Jonas

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Chris K. schrieb:
> Dass ich beide Programmteile bereits einzeln getestet habe, hatte ich
> schon erwähnt...das hast du vielleicht überlesen. Aber ist jetzt auch
> egal.

Das habe ich selbstverständlich nicht überlesen. Die Aussage, bei Tests 
sei kein Fehler aufgetreten, ist nicht äquivalent zur Fehlerfreiheit des 
Programms. Um letzteres behaupten zu können, müsste der Beweis 
vorliegen, dass es sich um eine vollständige Testabdeckung handelt, was 
in den allermeisten Fällen nicht möglich sein dürfte.

[Helmut L. (helmi1)]

Chris K. schrieb:
> ((pinD.bit2 == 1) & (pinD.bit3 == 0) & (pinD.bit4 == 0))

Die Unterschied zwischen binaeren & und logischen && kennst du?

Chris K. schrieb:
> Die Leitung zum anderen Controller beträgt
> übrigens ca. 15-20m.

Und du meinst das ist EMV technisch so in Ordnung?

Warum nimmst du nicht die Serielle Schnittstelle oder SPI des 
Controllers.
Und in deine Verbindung gehoeren Leitungstreiber und Empfaenger rein.

[m-obi (Gast)]

C-Progger schrieb:
> m-obi schrieb:
>> modus = (pinD >> 2) && 0x07;
>
> ... das ist keinen Deut besser :'(

Sorry meinte natürlich &. Ist auf jedenfall ein Deut besser. Wenn noch 
das & statt dem && gewesen wäre, wären es sogar zwei Deut ;).

[Wolfgang (Gast)]

Chris K. schrieb:
> Die Leitung zum anderen Controller beträgt
> übrigens ca. 15-20m.

Mal abgesehen vom Programmcode würde ich bei einer solchen Streckenlänge 
über was anderes als eine parallele Datenübertragung nachdenken. Wozu 
haben deine Controller einen U(S)ART oder ein SPI?

Als Einstiegsübung auf dem Hackbrett kann man das vielleich mal machen, 
aber sonst gibt es dafür eigentlich keine vernünftigen Gründe.
Und vergiss das Handshaking nicht, sonst sind Probleme mit undefinierten 
Zwischenzuständen vorprogrammiert.

[Chris K. (ati13)]

@ jibi
>Also diese bitorgie die auch noch fehler enthält:
>000
>100
>010
>110
>001
>101
>011
>111

Wenn Bit 5 das LSB und Bit 7 das MSB darstellen, sollte es doch passen 
oder?
000
001
010
011
100
101
110
111

@ C-Progger
>... das ist keinen Deut besser :'(
Was dann?

Danke für die Eure Hinweise.

[Karl H. (kbuchegg)]

Chris K. schrieb:

> Wenn Bit 5 das LSB und Bit 7 das MSB darstellen, sollte es doch passen
> oder?
> 000
> 001
> 010
> 011
> 100
> 101
> 110
> 111

Ja. Aber das geht viel einfacher.

Wieder:
den ganzen Port lesen. Das gelesene um 5 Bits nach rechts verschieben. 
Dann liegen die 3 inetressierenden Bits ganz unten im Byte. Mit einer 
Verundung mit 0x07 (binär: 00000111) alle nicht interessierenden Bits 
auf 0 setzen. Übrig bleibt eine Zahl von 0 bis 7. und wenn ich mir deine 
zu erzielenden Ergebniszahlen ansehe, dann folgen die dem Muster: 
Stufenzahl * 150 + 50

alles zusammen ergibt

   void geschw_lesen()
   {
     unsigned char stufe = ( PIND >> 5 ) & 0x07;
     geschw = stufe * 150  + 50;
   }

und jetzt vergleich mal mit dem Monster, das du geschrieben  hast und in 
dem du (natürlich) auch wieder alle logischen Und Operationen verbockt 
hast.

[Falk B. (falk)]

@ Karl Heinz (kbuchegg) (Moderator)

>und jetzt vergleich mal mit dem Monster, das du geschrieben  hast.

BUHHHHHH, das ist ja Losercode im hornalten C. Richtig fett aufgedunsen 
muss es, sein ala C++ und Java . . . . 8-0

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> und jetzt vergleich mal mit dem Monster, das du geschrieben  hast.

Fast. Noch nicht ganz.
Bei dir ist ja bei 7 die kleinste Stufe und bei 0 die größte.
Also muss man halt entweder

     geschw = ( 7 - stufe ) * 150  + 50;

oder aber man dreht einfach nach dem Einlesen gleich mal alle Bits um, 
so dass sich dann ebenfalls die Bedeutung umdreht.

     unsigned char stufe = ( ~PIND >> 5 ) & 0x07;

[Jonas B. (jibi)]

void geschw_lesen()
{
  return ((pinD.bit5<<2) | (pinD.bit6<<1) | (pinD.bit7<<0))*150;
}


Gruß Jonas

[Chris K. (ati13)]

Ich habe mit C++ angefangen, weil ich zu Anfang nur Java kannte. Für 
einfache "Anfängerbeispiele" haben diese Kenntnisse ausgereicht, zumal 
man sich dank SiSy nicht um h-Dateien oder sonstiges kümmern muss. ;-)
So langsam stoße ich da eben an grenzen...wie gut, das wir gerade das 
"gute alte C" behandeln ;-)

[Karl H. (kbuchegg)]

Chris K. schrieb:

> So langsam stoße ich da eben an grenzen...wie gut, das wir gerade das
> "gute alte C" behandeln ;-)

Das hat mit C wenig zu tun.

Wenn du µC programmierst, dann ist eines deiner wichtigsten Werkzeuge 
die Beherrschung der Bitoperationen.
Die braucht man auf Desktop-Systemen eher selten, weil man da 
tatsächlich eher wenig mit einzelnen Bits rummacht. Aber auf einem µC 
ist das anders: Da sind die Bitoperationen dein Lebenselexier, weil sich 
80% der ganze Programmierung nur mit der Manipulation von einzelnen Bits 
bzw. Bitfolgen beschäftigt. Und da ist dann auch das Aufdröseln in 
einzelne Bits nicht mehr zielführend, weil es viel zu umständlichen Code 
erzeugt.

Das ist so, wie eine Exponentialfunktion oder ein Logarithmus für einen 
BWL Studenten nichts wirklich wichtiges ist, als Naturwissenschaftler 
muss man aber mit diesen Operationen umgehen können.

Bitmanipulation

[Jonas B. (jibi)]

Achso rückwärts dann

test1 = 1050-(((bit5<<2) | (bit6<<1) | (bit7<<0))*150);

Gruss Jonas

[Falk B. (falk)]

@ Karl Heinz (kbuchegg) (Moderator)

>Das ist so, wie eine Exponentialfunktion oder ein Logarithmus für einen
>BWL Studenten nichts wirklich wichtiges ist,

Irrtum, es ist die Grundlage der Religion "Kapitalismus". Zinseszins und 
ewiges Wachstum . . .

> als Naturwissenschaftler
>muss man aber mit diesen Operationen umgehen können.

Ok, die Naturwissenschaftler können damit umgehen und wissen, dass 
expontielles Wachstum nicht ewig währt . . .

[Jonas B. (jibi)]

>000 = 0
>100 = 4
>010 = 2
>110 = 6
>001 = 1
>101 = 5
>011 = 3
>111 = 7

Merkst du was?

gruss  jonas

[Chris K. (ati13)]

@ jibi

Lies es doch einfach rückwärts ;-)
Ich frage erst das LSB und als letztes das MSB ab.

[Karl H. (kbuchegg)]

Falk Brunner schrieb:
> @ Karl Heinz (kbuchegg) (Moderator)
>
>>Das ist so, wie eine Exponentialfunktion oder ein Logarithmus für einen
>>BWL Studenten nichts wirklich wichtiges ist,
>
> Irrtum, es ist die Grundlage der Religion "Kapitalismus". Zinseszins und
> ewiges Wachstum . . .

Tja. Jetzt sag bloss das BWL-er das verstehen.
Banker, ja. Vielleicht. Solange es um die Zinsen geht, die sie kriegen.

[Karl H. (kbuchegg)]

Jonas Biensack schrieb:
> Achso rückwärts dann
>
> test1 = 1050-(((bit5<<2) | (bit6<<1) | (bit7<<0))*150);

Ich versteh immer noch nicht, was du damit bezweckst, 3 Bits an dieselbe 
Position zu schieben, um dann das Ergebnis mit 150 zu multiplizieren.

[Jonas B. (jibi)]

Warum an eine Stelle?

Ich schiebe bit5 an Stelle 2, bit5 an stelle1 und bit7 an stelle0.
Was meinst du?

gruß Jonas

[Jonas B. (jibi)]

>@ jibi

>Lies es doch einfach rückwärts ;-)

Ok 7,3,5,1....

DU WILLST ABER

7,6,5,4,3,2,1

Echt mal.

Gruß Jonas

[C-Progger (Gast)]

Jonas Biensack schrieb:
> Warum an eine Stelle?
>
> Ich schiebe bit5 an Stelle 2, bit5 an stelle1 und bit7 an stelle0.
> Was meinst du?
>
> gruß Jonas

Du schiebst:

Bit 5 2x nach links => Bit7
Bit 6 1x nach links => Bit7
Bit 7 0x nach links => Bit7


Also immer die gleiche Stelle... wo er Recht hat, hat er Recht

[Jonas B. (jibi)]

Hm, jetzt weiss ich was du meinst, ich hatte es vorher so einmal 
getestet:

  bit5 = true;
  bit6 = false;
  bit7 = false;

  test1 = 1050-(((bit5<<2) | (bit6<<1) | (bit7<<0))*150);

Da ist das nicht aufgefallen. Sorry.

Gruß Jonas

[MiWi (Gast)]

Chris K. schrieb:
> @ MiWi
>>Warum soll man sich hier also damit abgeben, auf solchen hingerotzten
>>Dreck auch noch inhaltlich einzugehen?
> (Zitat von schweigstill)
>
> Ich hab jetzt nach diversen Beiträgen, die sich inhaltlich sehr ähneln
> begriffen, dass ich mein Problem ausführlicher schildern soll.
> Aber solche besch...eidenen Beiträge (siehe Zitat) könnt ihr euch
> wirklich sparen! Ich wollte mein Anliegen doch einfach nur auf ein
> Minimum reduzieren. Anscheinend ist das so in Foren nicht üblich, weil
> man die Kenntnisse und Fähigkeiten der anderen nicht kennt.
> Gut. Das hab ich nun verstanden und poste die wichtigsten Details meines
> Projektes/Programmes:
>
> Zum Projekt allgemein:

Na also. Geht ja eh. Aber ohne diese Beiträge.....


Grüße & viel Erfolg

MiWi

[Chris K. (ati13)]

@ jibi

Ich meine statt:
000
100
010
110
...

-> 000
   001
   010
   011
   ...
siehe:

if ((pinD.bit5 == 0) & (pinD.bit6 == 0) & (pinD.bit7 == 0))...

Ich lese sozusagen von rechts (LSB) nach links (MSB).

Aber dieses "Monster" werde ich ja jetzt beseitigen...

[Wolfgang (Gast)]

Jonas Biensack schrieb:
> ich hatte es vorher so einmal getestet:
> ...
> Da ist das nicht aufgefallen.

Beweis durch Beispiel - oder wie nennt sich das?

Wie kommst du denn mit solchen Software-"Testmethoden" in Java klar. Das 
muss doch genauso schief gehen.

Andreas Schweigstill schrieb:
> solltest Du Dich erst einmal mehrere Jahre mit den Grundlagen der
> Testbarkeit von Software und Elektronik befasst haben.

Ack

[Jonas B. (jibi)]

>Beweis durch Beispiel - oder wie nennt sich das?

>Wie kommst du denn mit solchen Software-"Testmethoden" in Java klar. Das
>muss doch genauso schief gehen.

Ich glaub du vermischst hier zwei Personen, keine Ahnung wie du mit so 
einer Wahrnehmung klar kommst ;)

Gruß Jonas

[Chris K. (ati13)]

Also. Ich habe jetzt das "Monster" auf ein Minimum verkleinert. Guckst 
du hier:

void modus_lesen()
    {
      /*if ((pinD.bit2 == 0) & (pinD.bit3 == 0) & (pinD.bit4 == 0)){ 
        modus = 0;
      } else if ((pinD.bit2 == 1) & (pinD.bit3 == 0) & (pinD.bit4 == 0)){
        modus = 1;
      } else if ...*/
      
      modus = pinD & 0x07; // neue Variante
    }

bzw.

void geschw_lesen()
    {
      /*if ((pinD.bit5 == 0) & (pinD.bit6 == 0) & (pinD.bit7 == 0)){
        geschw = 1100;
      } else if ((pinD.bit5 == 1) & (pinD.bit6 == 0) & (pinD.bit7 == 0)){
        geschw = 950;
      } else if ...*/
      
      geschw = ((~pinD >> 3) & 0x07) * 150 + 50; // neue Variante 
    }

Sollte denk ich auch das bei rauskommen, was ich haben will.

Außerdem habe ich das Einleseprogramm verbessert, z.B.:

if ((moduswahl > 400) && (moduswahl <= 600)){
          portB = (0b00000010 + geschw_ermitteln());  // Lauftlicht nach unten
        }

(hatte vorher fälschlicher Weise das einfache, binäre UND verwendet)

Sonst habt ihr im Einleseprogramm keine weiteren Fehler entdecken 
können?

[m-obi (Gast)]

Wenn du Bit 2, 3 und 4 willst musst du dann nicht mit 0x1C prüfen?

[Chris K. (ati13)]

Ah na klar, danke!

void modus_lesen()
    {
      modus = pinD & 0x1C; // Bits 2-4 "einlesen"
    } 
 
    void geschw_lesen()
    {     
      geschw = (~pinD & 0xE0) * 150 + 50; // Bits 5-7 "einlesen"  
    }

So könnte es passen.

[Karl H. (kbuchegg)]

Chris K. schrieb:
> Ah na klar, danke!
>
>

void modus_lesen()
>     {
>       modus = pinD & 0x1C; // Bits 2-4 "einlesen"
>     }
> 
>     void geschw_lesen()
>     {
>       geschw = (~pinD & 0xE0) * 150 + 50; // Bits 5-7 "einlesen"
>     }

>
> So könnte es passen.

Nein.
Denn wenn du an den Bits 2, 3 und 4 interessiert bist, dann musst du die 
auch gaaaanz nach unten schieben, damit sich da die von dir gewünschten 
Zahlen von 0 bis 7 ergeben.


Ist doch ganz simpel.
Du bist beispielsweise an diesen Bits hier interessiert und willst das 
ganze so haben, dass du diese Bits in ihrer Gesamtheit als Zahlen 
benutzen kannst.

Diese Bits a - d willst du ( 4 Stück Bits, daher Zahlen von 0 bis 15 )

 
     7   6   5   4   3   2   1   0
   +---+---+---+---+---+---+---+---+
   | x | x | d | c | b | a | x | x |
   +---+---+---+---+---+---+---+---+

Alle mit x markierten Bits sind für dich uninteressant.

Zuerst mal schiebst du den ganzen Wust um 2 Bits nach rechts. Warum 2 
Bits? Na weil das Bit a an der Bitposition 2 ist. Damit es ganz nach 
rechts rutscht, schiebst du es um 2 Bits

     value = value >> 2

 
     7   6   5   4   3   2   1   0
   +---+---+---+---+---+---+---+---+
   | 0 | 0 | x | x | d | c | b | a |
   +---+---+---+---+---+---+---+---+

Jetzt sind die 4 Bits ganz rechts. Aber links sind noch ein paar mit x 
markierte Bits, deren Wert du erstens nicht kennst und die dich zweitens 
auch nicht interessieren.
Also machst du eine binäre Und-Verknüpfung und wendest eine Maske an, 
die dir nur die 4 interessierenden Bits übrig lässt und alle andern Bits 
(selbst wenn sie schon auf 0 waren) gezielt auf 0 zwingt.

   value = value & 0x0F;

oder

   value = value & 0b00001111;

oder

   value = value & ( (1 << PB0) | (1 << PB1) | (1 << PB2) | (1<<PB3) );

oder

   value = value & ~( (1<<PB7) | (1<<PB6) | (1<<PB5) | (1<<PB4) );

Alle Varianten sind nur unterschiedliche Schreibweisen für dasselbe: 
Eine Bitmaske, in der an den interessierenden Bits ein 1-Bit steht und 
alle andern Bits 0 sind. Die 0 Bits erzwingen, dass im Ergebnis getreu 
der Und-Verknüpfung für Bits

UND

   a    b     Ergebnis
  ---------------------
   0    0        0
   1    0        0
   0    1        0
   1    1        1

(b ist quasi das jeweilige Bit aus der 'Maske', während a dem Bit in value entspricht)

in jedem Fall eine 0 auftaucht (Kontrolliere: In der Und-Tabelle sind 
alle Ergebnis Zeilen tatsächlich 0, in denen auch in der b-Spalte eine 0 
steht. Wohingegen in den Zeilen, in denen b auf 1 steht, das Ergebnis 
identisch mit der jeweiligen a Spalte ist.)

Die Operation ist dann

 
           7   6   5   4   3   2   1   0
         +---+---+---+---+---+---+---+---+
         | 0 | 0 | x | x | d | c | b | a |
         +---+---+---+---+---+---+---+---+

UND
         +---+---+---+---+---+---+---+---+
         | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 1 |
         +---+---+---+---+---+---+---+---+

---------------------------------------------

         +---+---+---+---+---+---+---+---+
         | 0 | 0 | 0 | 0 | d | c | b | a |
         +---+---+---+---+---+---+---+---+

      auf jede Spalte einzeln die Und-Verknüpfung anwenden!
      Genau das ist es, was die binäre Und-Verknüpfung in C++ (bzw. C)
      macht! binäre Und Verknüpfung schreibt sich als &
      Im Gegensatz zur logischen Und Verknüpfung, die sich als && schreibt.

Das Eregbnis ist also ein Byte, in dem deine interessierenden Bits ganz 
rechts stehen und unversehrt übernommen wurden, während alle anderen 
Bits definitiv auf 0 sind.

Und getreu

     Bits    Hex Dezimal        Bits   Hex Dezimal
     0000     0     0           1000    8    8
     0001     1     1           1001    9    9
     0010     2     2           1010    A   10
     0011     3     3           1011    B   11
     0100     4     4           1100    C   12
     0101     5     5           1101    D   13
     0110     6     6           1110    E   14
     0111     7     7           1111    F   15

steht jede der Bitkombinationen für eine Zahl. In dem Fall, mit 4 Bits, 
dann eben für Zahlen von 0 bis 15.
Genau das, was wir wollten. Denn mit den Zahlen wollen wir ja 
weiterrechnen bzw. etwas damit machen.


Du musst natürlich nicht um 2 Bits schieben. Nur kommen dann eben nicht 
Zahlen von 0 bis 15 raus, sondern andere. Das kann  manchmal sinnvoll 
sein, wenn man aber an den Zahlen als solche explizit interessiert ist, 
dann ist es meist einfacher, die Schiebe-Operation zu machen. Wir tun 
uns eben mit der Zahlenfolge 0, 1, 2, 3, 4, ... 15 leichter, als mit der 
Zahlenfolge 0, 4, 8, ... 60. Vor allen Dingen dann, wenn dann damit noch 
gerechnet werden soll.

[Chris K. (ati13)]

Vielen dank kbuchegg für die sehr ausführliche Nachhilfe!
So ausführlich wäre sie eigentlich nicht notwendig gewesen...
Mein Problem ist, dass ich zu flüchtig über die Problemstellungen 
nachdenke, um möglichst schnell ein Ergebnis zu bekommen oder zu sehen.

Also hier nochmal die überarbeitete Variante:

void modus_lesen()
    {
      modus = (pinD >> 2) & 0x07;
    }  
    
    void geschw_lesen()
    {
      geschw = (~(pinD >> 5) & 0x07) * 150 + 50;  
    }

[Chris K. (ati13)]

Noch eine kleine Frage.
Für mein Projekt benötige ich ja 2 µC. bis jetzt habe ich immer das 
"myAVR Board MK2" für Übungszwecke verwendendet. Darauf befindet sich 
bereits ein ATmega8. Einen weiteren Atmega8 habe ich aber nicht zur 
Hand, sondern nur einen ATmega32 (war im Einsteigerset mit enthalten). 
Ich habe jetzt zum Testen des neuen Controllers zunächst die 
Grundschaltung (Minimalbeschaltung) aufgebaut, danach einen Taster und 
LED's angeschlossen und ein simples Programm draufgeladen welches die 
LED's bei Betätigen eines Tasters aufleuchten lässt. Und es 
passiert...nichts. Reicht die Minimalbeschaltung auf dem Bild 
tatsächlich aus? Habe z.B. keinen entsprechenden Kondensator zur Hand. 
Aber ich möchte ja auch nur kurz die Funktion testen, mehr nicht. Gibt 
es noch etwas zu beachten, wenn einen neuen µC zum ersten mal 
programmiert oder in Betrieb nimmt?

[Chris K. (ati13)]

(Bild)

[Karl H. (kbuchegg)]

Chris K. schrieb:

> passiert...nichts. Reicht die Minimalbeschaltung auf dem Bild
> tatsächlich aus?

An Avcc/AGND sollte noch ein 100nF Kondensator ran.

> Habe z.B. keinen entsprechenden Kondensator zur Hand.

Das ist schlecht.

Aber: Es kann auch ohne Kondensator funktionieren. Sicherer ist mit.

> Aber ich möchte ja auch nur kurz die Funktion testen, mehr nicht. Gibt
> es noch etwas zu beachten, wenn einen neuen µC zum ersten mal
> programmiert oder in Betrieb nimmt?

Nein.

Ausser das du schon wieder zu kompliziert loslegst.
Du musst erst noch lernen, dass das Arbeiten in kleinen SChritten nur 
auf den ersten Blick langsamer aussieht. Es wird noch einige Zeit 
dauern, bis du sweit bist, dass deine Schritte größer werden können.

Ein erstes Testprogramm ist: EINE Led an einem Portpin. Die schaltet man 
ein. Im nächsten Testprogramm schaltet man sie aus (auch wenn das 
paradox klingt. Es geht darum festzustellen, ob die leuchtende LED im 
erste Testprogramm auch wirklich deswegen geleuchtet hat, weil man im 
Programm eingeschaltet hat). Dann vielleicht mal blinken. Dann 
vielleicht 8 Led an den Portpins und die gemeinsam blinken lassen (damit 
stellt man zb fest: ob der sprunghafte Anstieg im Stromverbrauch 
irgendwelche negativen Effekte in der Spannungsversorung hat). Und erst 
dann kommt erstmalig ein Taster ins Spiel.

> So ausführlich wäre sie eigentlich nicht notwendig gewesen...

Macht nix. Wenn ich mir den Krampf ansehe, mit dem du losgestartet bist, 
hab ich schon den Eindruck, du kannst noch gar nicht abschätzen, wieviel 
Mehrarbeit du dir da überall gemacht hast und immer noch machst.

> Mein Problem ist, dass ich zu flüchtig über die Problemstellungen
> nachdenke, um möglichst schnell ein Ergebnis zu bekommen oder zu sehen.

Tja. Computer sind da gnadenlos. Da musst du sorgfältiger werden.
Das bedeutet auch, in kleineren Schritten zu arbeiten. Mit der einfachst 
möglichen Problemstellung anfangen (so wie bei den LED und dem Taster) 
und dich dann in kleinen SChritten vorarbeiten, wobei jeder SChritt 
getestet wird. Denn sonst wird es immer so weiter gehen, dass du mit 
einem komplexen Produkt dasteht, nichts funktioniert und du hast keine 
Ahnung, wo du mit Fehlersuche anfangen sollst oder du hast noch nicht 
mal den Hauch einer Idee, was da nicht stimmen könnte.
Wie gesagt: Auf lange Sicht bist du mit schrittweisem Vorgehen immer 
schneller, als wie wenn du gleich zu viel willst.

[Chris K. (ati13)]

Gut. Dass ich kleinschrittiger und sorgfältiger arbeiten muss, werde ich 
jetzt beherzigen.
Ich habe mit Absicht nicht nur eine, sondern 6 LED's angeschlossen, um 
zu prüfen, ob der (gesamte) Port für die geplante Übertragung der Bits 
fehlerfrei funktioniert. Den Taster hätte ich dabei allerdings weglassen 
können. Im übrigen leuchten die LED's nun, war natürlich wieder mal ein 
Flüchtigkeitsfehler...

Ich habe jetzt außerdem herausgefunden, weshalb der ATmega32 mit dem 
Programm zum Einlesen der Werte über die ADC-Kanäle nicht funktioniert 
hat. Beim Anlegen eines neuen "kleinen Programmes" (SiSy) öffnet sich 
ein Fenster für diverse Einstellungen. Dort muss man bereits den 
benutzten Controllertyp auswählen. Mit diesen Einstellungen wird das 
Programm dann wahrscheinlich kompiliert. Nach dem Kompilieren hat man 
aber ebenfalls die Möglichkeit, den Controllertyp einzustellen (was ich 
bisher getan hatte). Ich hab also ein Programm für einen Mega8 
gescchrieben auf einen Mega32 geladen (warum so etwas überhaupt möglich 
ist, ist mir unklar). Das nächste Problem ist, dass das Paket mit den 
vorgefertigten Klassen, welches ich benutze, nicht mit dem Mega32 
kompatibel ist (laut Compiler).
Da ich ein wenig unter Zeitdruck stehe, werde ich mir wohl einen zweiten 
Mega8 besorgen - den ich ja sowieso dafür vorgesehen hatte - anstatt das 
Programm (wahrscheinlich wieder zu schnell, zu hektisch und vor allem 
falsch) umzuschreiben...