Auswahl I2C Bus Adresse durch DIP umschaltbar

[Paul (Gast)]

Hallo
Möchte mit abn einem Attiny 841 verschiedene I2C Bus Adressen mit 
Dip-Scaltern bzw. Steckbrücken umschalten können. Leider ist die Suche 
auf Google und anderen Kanälen sehr spärlich.

Hardware:
A0 - PA1 mit Widerstand nach Vcc
A1 - PA2 mit Widerstand nach Vcc
jeweils nach GND schaltbar

#define Adress_G        // Slave Adresse Auswahl
#define Adress_1  0x32    // Slave Adresse 1
#define Adress_2  0x34    // Slave Adresse 2
#define Adress_3  0x36    // Slave Adresse 1+2

if ( PORTA &=~(1<<PINA1)    // A0 auf GND
  {                
  Adress_G = Adress_1;    // 0x32
  }

if ( PORTA &=~(1<<PINA2)    // A1 auf GND
  {
  Adress_G = Adress_2;    // 0x34
  }

if ((PORTA &=~(1<<PINA1))&(PORTA &=~(1<<PINA1)))    // A0 und A1 auf GND
  {
  Adress_G = Adress_3;    // 0x36
  }

Habe drei Adressen angegeben die jeweils nach Stellung der Pins 
ausgewählt werden können. Die Abfrage der Adresse erfolgt bereits am 
Anfang des Programmes. Da mit 2 Pins 4 Adressen möglich sind fehlt novh 
die Kombination Adress_4 wenn beide Dip offen sind.
Könnte das so gehn oder kennt jemand eine bessere Lösung dazu?
LG Paul

[leo (Gast)]

Paul schrieb:
> if ( PORTA &=~(1<<PINA1)    // A0 auf GND

Was jetzt A0 oder A1?

leo

[leo (Gast)]

Paul schrieb:
> if ( PORTA &=~(1<<PINA1)

Ah ja, &= ist eine Zuweisumg, kein Vergleich.

leo

[Route_66 H. (route_66)]

Paul schrieb:
> Könnte das so gehn oder kennt jemand eine bessere Lösung dazu?
> LG Paul

PORTA mit 0x03 maskieren(AND 0x03), mal zwei nehmen, dazu 0x30 addieren 
und Adress_G zuweisen.
Dann hast Du für Adress_G den Wert von 36h bis 30h (weil invertiert).

[Wolfgang (Gast)]

Paul schrieb:
> Könnte das so gehn oder kennt jemand eine bessere Lösung dazu?

#define S1 (1<<PINA1)
#define S2 (1<<PINA2)
 
uint8_t Schalter = PORTA & (S1 | S2);

switch Schalter 
{
  case  0:    ...;
  case S1:    ...;
  case S2:    ...;
  case S1|S2: ...;
}

[Wolfgang (Gast)]

Route_66 H. schrieb:
> PORTA mit 0x03 maskieren(AND 0x03), mal zwei nehmen, dazu 0x30 addieren
> und Adress_G zuweisen.

Wie kommst du drauf, dass (1<<PINA1)|(1<<PINA2) gleich 0x03 ist?

[Theor (Gast)]

@ Paul

Nun, zufällig ergeben die beiden Schalter an PA1 und PA2 gerade die 
Werte, 0, 2, 4 und 6. Das kann man nutzen, denn Deine Adressen haben 
genau diese Abstände.

uint8_t Adress_G; // NICHT #define Adress_G

Adress_G = 0x30 + (PINA & 0x06);

wobei der Sonderfall (PINA & 0x06) == 0 damit nicht abgedeckt ist. Aber 
Du hast auch nicht geschrieben, was dann geschehen soll.


Falls die Adressen völlig unregelmäßige Abstände haben, kann man 
trotzdem noch die Tatsache nutzen, dass die Eingangswerte konstante 
Abstände haben.

uint8_t Adress_G;
uint8_t AdressArray[4] = {0, 0x43, 0xa4, 0x8f};

Adress_G = AdressArray[(PINA & 0x06) >> 1];

Eigentlich total einfach, oder?

[Paul (Gast)]

Route_66 H. schrieb:
> PORTA mit 0x03 maskieren(AND 0x03), mal zwei nehmen, dazu 0x30 addieren
> und Adress_G zuweisen.
> Dann hast Du für Adress_G den Wert von 36h bis 30h (weil invertiert).

Die Adressen werden durch #define im ersten Teil vergeben. Können also 
irgendwelche Werte annehmen. Mit A0 und A1 habe ich die Dip-Schalter 
bezeichnet und beziehen sich nicht auf die Pins. Das habe ich in der 
Hardware angegeben.

#define Adress_G        // Slave Adresse Auswahl
#define Adress_1  0x32    // Slave Adresse 1
#define Adress_2  0x34    // Slave Adresse 2
#define Adress_3  0x36    // Slave Adresse 1+2
#define Adress_4  0x38    // Slave Adresse nicht 1+2

if ( PORTA &=~(1<<PINA1)    // A0 auf GND Dip Schalter
  {                
  Adress_G = Adress_1;    // 0x32
  }

if ( PORTA &=~(1<<PINA2)    // A1 auf GND Dip Schalter
  {
  Adress_G = Adress_2;    // 0x34
  }

if (((PORTA &=~(1<<PINA1))&(PORTA &=~(1<<PINA1)))  // A0 und A1 auf GND DIP Schalter
  {
  Adress_G = Adress_3;    // 0x36
  }

if (((PORTA |=(1<<PINA1))&(PORTA |=(1<<PINA2)))     // A0 und A1 nicht auf GND Dip Schalter
  {
  Adress_G = Adress_4;    // 0x38
  }

[Route_66 H. (route_66)]

Wolfgang schrieb:
> Wie kommst du drauf, dass (1<<PINA1)|(1<<PINA2) gleich 0x03 ist?

O.K. ich habe erst mal nur A0 und A1 gelesen, so ist die Maske 0x06 und 
das mal zwei entfällt.

[Theor (Gast)]

Ups. Mein Code, invertiert die Bedeutung der Bits und gibt nicht das 
identische Verhalten von Deinem Code.

uint8_t Adress_G; // NICHT #define Adress_G

Adress_G = 0x30 + (~PINA & 0x06);

uint8_t Adress_G;
uint8_t AdressArray[4] = {0, 0x43, 0xa4, 0x8f};

Adress_G = AdressArray[(~PINA & 0x06) >> 1];

Allerdings wäre es einfacher, einfach die Bedeutung der Schalterstellung 
umzudrehen.
Naja. Das wird vermutlich nur einmal im Leben (nach dem Reset( 
ausgeführt. Aber in bisschen Code frisst die Negation doch.


Ach ja. Das "&=" in Deinem Code ist falsch. Du willst - vermutlich - 
nicht das invertierte Resultat wieder dem Port zuweisen.

[Andre (Gast)]

Sind das zwei aufeinander folgende Pins?
Dann könntest du sowas machen:
uint8_t select = (PINA & 0b00000110) >> 1;

Das pickt sich die zwei Bits für Pin A1/A2 raus und richtet sie am LSB 
aus.
Das Ergebnis davon kannst du mit Switch/Case auswerten, die 
Schalterstellung steht dann binär 00/01/10/11 in "select".
Funktioniert aber nicht universell.

[Paul (Gast)]

Sorry, bekomme eine Fehlermeldung die ich nicht verstehe.

if ( PORTA &=~(1<<PINA1))    // A0 auf GND Dip Schalter
  {
    Adress_G = Adress_1;  // 0x32
  }
ergibt den Fehler:
expected expression before '=' token

[Paul (Gast)]

ES wird was anderes von Adress_G erwartet?

[leo (Gast)]

Paul schrieb:
> ergibt den Fehler:
> expected expression before '=' token

Vielleicht solltest du meine Posts lesen.

leo

[Klaus R. (klara)]

Paul schrieb:
> Möchte mit abn einem Attiny 841 verschiedene I2C Bus Adressen mit
> Dip-Scaltern bzw. Steckbrücken umschalten können.

Ein I2C - Baustein bringt doch von Haus aus bis zu drei Adress - Pins 
mit. Wozu speicherst Du die DIP - Einstellung in einer Variable? Bei mir 
gehe ich direkt vom DIP auf die Adress - Pins und gut ist es.
mfg Klaus.

[Paul (Gast)]

Als Slave verwende ich einen Attiny 841. Der hat von Hause aus keine 
Adressen vergeben und muss im Programm eingestellt werden.

[Ernst (Gast)]

Paul schrieb:
> ES wird was anderes von Adress_G erwartet?
Du solltest Dir erstmal im klaren sein, in welcher Zeile sich der Fehler 
befindet.

leo schrieb:
> Vielleicht solltest du meine Posts lesen.
Dem stimme ich zu.

[Wolfgang (Gast)]

Paul schrieb:
> if ( PORTA &=~(1<<PINA1)    // A0 auf GND Dip Schalter
> ...

Dieses endlose IF-Gezuzel ist doch Käse.

Andre schrieb:
> Das Ergebnis davon kannst du mit Switch/Case auswerten, ...

Aaach, lies mal weiter vorne im Thread

Wolfgang schrieb:

[Einer K. (Gast)]

leo schrieb:
> Vielleicht solltest du meine Posts lesen.
? ? ?

> #define Adress_G        // Slave Adresse Auswahl
> Adress_G = Adress_4;


> ergibt den Fehler:
> expected expression before '=' token

Natürlich!
Ein solches, per define erzeugtes, ist ein Nichts, aus Sicht des 
Compilers.
Es kann kein Ziel einer Zuweisung sein.
Es ist kein lvalue und hat auch keine Chance jemals eins zu werden..

[Peter D. (peda)]

Paul schrieb:
> if ( PORTA &=~(1<<PINA1)    // A0 auf GND

Mindestens 2 Fehler:
- Du wertest eine Zuweisung aus.
- Das Ausgangsregister (PORTA) wird nicht von den Eingangspins 
beeinflußt.

[Paul (Gast)]

Habe es jetzt so gemacht:

uint8_t I2C_SLAVE_ADDRESS;  
void adresswahl()
  {  
    if (PORTA &=~(1<<PINA1))    // A0 auf GND Dip Schalter
      {                
        I2C_SLAVE_ADDRESS = Adress_1;
    }
    if ( PORTA &=~(1<<PINA2))    // A1 auf GND Dip Schalter
      {
      I2C_SLAVE_ADDRESS = Adress_2;    // 0x34
      }
    if ((PORTA &=~(1<<PINA1))&(PORTA &=~(1<<PINA1)))  // A0 und A1 auf GND DIP Schalter
      {
      I2C_SLAVE_ADDRESS = Adress_3;    // 0x36
      }
    if ((PORTA |=(1<<PINA1))&(PORTA |=(1<<PINA2)))     // A0 und A1 nicht auf GND Dip Schalter
      {
      I2C_SLAVE_ADDRESS = Adress_4;    // 0x38
      }
  }

Gehe da von aus, wenn der Dip-Schalter den PIN A1 auf GND legt die 
Bedingung erfüllt ist und if=1 ist.

[Einer K. (Gast)]

Paul schrieb:
> if ((PORTA &=~(1<<PINA1))&(PORTA &=~(1<<PINA1)))

Was tust du da?
Mir fehlt dafür jegliches Verständnis.
Mit Dip-Schalter auslesen hat das doch nichts zu tun, oder?

[Egonwalter M. (heiner1234)]

Hallo Paul

Du solltest den Beitrag von Peter.D (peda)

Peter D. schrieb:
> Paul schrieb:
>> if ( PORTA &=~(1<<PINA1)    // A0 auf GND
>
> Mindestens 2 Fehler:
> - Du wertest eine Zuweisung aus.
> - Das Ausgangsregister (PORTA) wird nicht von den Eingangspins
> beeinflußt.

mal überdenken.

Außerdem die Sache mit den Bit-Operationen (ebenfalls Beitrag von peda - 
siehe "Taster entprellen")

Hast Du das von Dir geschriebene schon mal am "lebendigen Objekt" 
getestet??

[Paul (Gast)]

Ja, habe das Programm auf der Hardware zu laufen.
Einen Fehler habe ich gefunden. Hatte die Reihenfolge von

adresswahl();
I2C_init();

falsch herum drin

[Paul (Gast)]

Vergesst den ersten Teil. Keine Ahnung wie ich das falsch gemacht habe

uint8_t I2C_SLAVE_ADDRESS;  
void adresswahl()
  {  
  if (!(PINA & (1<<PINA1)))    // A0 auf GND Dip Schalter
      {                
        I2C_SLAVE_ADDRESS = Adress_1;    // 0x32
    }
    if (!(PINA & (1<<PINA2)))    // A1 auf GND Dip Schalter
      {
      I2C_SLAVE_ADDRESS = Adress_2;    // 0x34
      }  
  if (!((PINA & (1<<PINA1))&(PINA & (1<<PINA2))))// A0 und A1 auf GND DIP Schalter
      {
      I2C_SLAVE_ADDRESS = Adress_3;    // 0x36
      }  
  if ((PINA & (1<<PINA1))&(PINA & (1<<PINA2)))  // A0 und A1 nicht auf GND Dip Schalter
      {
      I2C_SLAVE_ADDRESS = Adress_4;    // 0x38
      }
  }

damit wird die Busaderesse 0x34 und 0x36 erkannt

[leo (Gast)]

Paul schrieb:
> if ((PINA & (1<<PINA1))&(PINA & (1<<PINA2)))

So, jetzt kannst du noch den Unterschied von logischen und binaeren 
Operatoren nachschlagen und anwenden.

leo

[Peter D. (peda)]

Wolfgang schrieb:
> #define S1 (1<<PINA1)
> #define S2 (1<<PINA2)
>
> uint8_t Schalter = PORTA & (S1 | S2);
>
> switch Schalter
> {
>   case  0:    ...;
>   case S1:    ...;
>   case S2:    ...;
>   case S1|S2: ...;
> }

Fast richtig.

#define S1 (1<<PINA1)
#define S2 (1<<PINA2)
 
uint8_t Schalter = PINA & (S1 | S2);

switch Schalter 
{
  case  0:    ...;
  case S1:    ...;
  case S2:    ...;
  case S1|S2: ...;
}

[Wolfgang (Gast)]

Paul schrieb:
> damit wird die Busaderesse 0x34 und 0x36 erkannt

Man muss auch mal Glück haben, aber verstanden hast du wohl nicht, was 
du hier geschrieben hast:

> if (!((PINA & (1<<PINA1))&(PINA & (1<<PINA2))))// A0 und A1 auf GND
> DIP Schalter

[Paul (Gast)]

Wolfgang schrieb:
> if (!((PINA & (1<<PINA1))&(PINA & (1<<PINA2))))

Damit will ich PINA1 "und" PINA2 negieren. Wenn beide auf GND liegen 
soll if schalten

[Wolfgang (Gast)]

Peter D. schrieb:
> Fast richtig.

Stimmt, die break -Befehle sollten nicht fehlen

[Wolfgang (Gast)]

Paul schrieb:
> Wenn beide auf GND liegen soll if schalten

Auch wenn nicht beide auf Gnd liegen, kommt bei
(PINA & (1<<PINA1))&(PINA & (1<<PINA2)) ein 0x00 raus.

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

Paul schrieb:
> Da mit 2 Pins 4 Adressen möglich sind fehlt novh die Kombination
> Adress_4 wenn beide Dip offen sind.
> Könnte das so gehn oder kennt jemand eine bessere Lösung dazu?
Wenn die beiden Bits so geschickt nebeneinander liegen, dann lese ich 
die parallel ein und addiere den ermittelten Wert zum Offset 0x30:

 uint8_t adresse = 0x30 + (PINA & 0x6);

Das ergibt je nach Schalterstellung die Adressen 0x30, 0x32, 0x34 oder 
0x36 und man muss letztlich nur noch die entsprechende Doku so 
schreiben, dass sie zu den Schalterstellungen passt.

Wenn die Doku leider vorher schon ohne über die Hardware nachzudenken 
geschrieben wurde, ist das echt "Pech" und man muss den passenden 
programmtechnischen Eiertanz machen. Daraus kann man für die Zukunft 
lernen...

[Eric B. (beric)]

Peter D. schrieb:
> switch Schalter

Fast richtig ;-)

switch(Schalter)

[Wolfgang (Gast)]

Eric B. schrieb:
> Fast richtig ;-)

Das sollte Pseudo-Code sein, kein C ;-)

[Paul (Gast)]

Mit diesem Code kann ich die 4 möglichen Adressen einstellen.

uint8_t I2C_SLAVE_ADDRESS;  
void adresswahl()
  {  
  if (!(PINA & (1<<PINA1)))      // A0 auf GND Dip Schalter
      {                
        I2C_SLAVE_ADDRESS = Adress_1;  // 0x32
    }
    if (!(PINA & (1<<PINA2)))      // A1 auf GND Dip Schalter
      {
      I2C_SLAVE_ADDRESS = Adress_2;  // 0x34
      }  
    
  if ((!(PINA & (1<<PINA1))) && (!(PINA & (1<<PINA2))))// A0 und A1 auf GND DIP Schalter
      {
      I2C_SLAVE_ADDRESS = Adress_3;  // 0x36
      }  
    
  if ((PINA & (1<<PINA1)) && (PINA & (1<<PINA2)))  // A0 und A1 nicht auf GND Dip Schalter
      {
      I2C_SLAVE_ADDRESS = Adress_4;  // 0x38
      }  
  }

Versuchen wir noch die zweite Version

[Karl M. (Gast)]

Hallo Code soll auch lesbar und somit auch einfach kontrollierbar, für 
andere sein.
Somit bleibt nur diese Variante der Kodierung übrig.
Peter D. schrieb:
> #define S1 (1<<PINA1)
> #define S2 (1<<PINA2)
>
> uint8_t Schalter = PINA & (S1 | S2);
>
> switch (Schalter)
> { // S[2,1] betrachtet die Eingangsmenge der Schalterstellung(en) von S2 und S1
>   case  0:    ...; // S[2,1] == 0b00
>     break;
>   case S1:    ...; // S[2,1] == 0b01
>     break;
>   case S2:    ...; // S[2,1] == 0b10
>     break;
>   case S1|S2: ...; // S[2,1] == 0b11
>     break;
> }

Man kann natürlich beim lesen von PINA, dessen Werte mit NOT (in C: !) 
negieren.

[leo (Gast)]

Karl M. schrieb:
> PINA, dessen Werte mit NOT (in C: !)
> negieren.

Kann man, ist aber falsch. Der naechste, der sich den Unterschied von 
logischen und binaeren Operatoren aneignen sollte.

leo

[Wolfgang (Gast)]

Karl M. schrieb:
>   case S1:    ...; // S[2,1] == 0b01
> ...
Deine Kommentare stimmen nicht mehr, sobald die Schalter auf anderen 
Bits liegen - schon wieder so eine Kommentarfalle.

[Paul (Gast)]

Haeb die Auswahl für die Adresse auf 3 Schalter erweitert und kann somit 
zwischen 8 Busadressen auswählen.

[Paul (Gast)]

Habe die Sache mit switch umgesetzt. Ist aber noch ein Denkfehler drin.

void auswahl_sw()
{
 uint8_t Schalter = PINA & (S1 | S2);

 switch (Schalter)
   {              // betrachtet die Eingangsmenge der Schalterstellung(en) von S1 und S2
     case  0:    I2C_SLAVE_ADDRESS = Adress_1;    // Adresse 0x22 A0 auf GND
       break;
     case S1:    I2C_SLAVE_ADDRESS = Adress_2;    // Adresse 0x24 A1 auf GND
       break;
     case S2:    I2C_SLAVE_ADDRESS = Adress_3;    // Adresse 0x26
       break;
     case S1|S2: I2C_SLAVE_ADDRESS = Adress_4;    // Adresse 0x28 A0 + A1 auf GND
       break;
   }
}

Es ergeben sich nicht die gewünschten Adressen mit den beiden S1 und S2. 
Die Ergebnisse habe ich als Kommentar angegeben.

[Wolfgang (Gast)]

Paul schrieb:
> Die Ergebnisse habe ich als Kommentar angegeben.

Versteh' ich nicht. Sind deine Adressen immer noch die selben?
Zeig mal das komplette Programm.

Paul schrieb:
> #define Adress_1  0x32    // Slave Adresse 1
> #define Adress_2  0x34    // Slave Adresse 2
> #define Adress_3  0x36    // Slave Adresse 1+2

[Paul (Gast)]

Hatte vorher mit if auf 8 Adressen erweitert. Jetzt sieht es so aus:

#define Adress_1  0x22    // Slave Adresse 1
#define Adress_2  0x24    // Slave Adresse 2
#define Adress_3  0x26    // Slave Adresse 3
#define Adress_4  0x28    // Slave Adresse 1+2

uint8_t I2C_SLAVE_ADDRESS;  

#define S1 (1<<PINA1)
 #define S2 (1<<PINA2)

void auswahl_sw()
{
 uint8_t Schalter = PINA & (S1 | S2);

 switch (Schalter)
   {              // betrachtet die Eingangsmenge der Schalterstellung(en) von S1 und S2
     case  0:    I2C_SLAVE_ADDRESS = Adress_1;    // Adresse 0x22 A0 auf GND
       break;
     case S1:    I2C_SLAVE_ADDRESS = Adress_2;    // Adresse 0x24 A1 auf GND
       break;
     case S2:    I2C_SLAVE_ADDRESS = Adress_3;    // Adresse 0x26
       break;
     case S1|S2: I2C_SLAVE_ADDRESS = Adress_4;    // Adresse 0x28 A0 + A1 auf GND
       break;
   }
}

auswahl_sw();
I2C_init();

habe nur die Adressen geändert. Eine Auswahl erfolgt ja, nur eben 
falsch.
Habe die Teile hier nicht drin die funktionieren z.B. Timer und ISR.

[Paul (Gast)]

#define Adress_1  0x22    // Slave Adresse 1
#define Adress_2  0x24    // Slave Adresse 2
#define Adress_3  0x26    // Slave Adresse 3
#define Adress_4  0x28    // Slave Adresse 1+2
#define Adress_5  0x30    // Slave Adresse 1+3
#define Adress_6  0x32    // Slave Adresse 2+3
#define Adress_7  0x34    // Slave Adresse 1+2+3
#define Adress_8  0x36    // Slave Adresse nicht 1+2+3

switch (Schalter)
   {              // betrachtet die Eingangsmenge der Schalterstellung(en) von S1 und S2
     case  0:    I2C_SLAVE_ADDRESS = Adress_1;    // Adresse 0x22 A0 auf GND
       break;
     case S1:    I2C_SLAVE_ADDRESS = Adress_2;    // Adresse 0x24 A1 auf GND
       break;
     case S2:    I2C_SLAVE_ADDRESS = Adress_3;    // Adresse 0x36 bei A0 und A1 auf Vcc (offen)
       break;
     case S1|S2: I2C_SLAVE_ADDRESS = Adress_4;    // Adresse 0x28 A0 + A1 auf GND
       break;
   }

alle verwendeten Adressen
bei Adresse 3 ergibt sich 0x36

[Wolfgang (Gast)]

Paul schrieb:
> Habe die Teile hier nicht drin die funktionieren z.B. Timer und ISR.

Wenigstens die Programmstruktur sollte sichtbar sein.

Lass dir am Ende von der Funktion auswahl_sw() die Werte für Schalter 
und I2C_SLAVE_ADDRESS mal ausgeben, am besten in Hex.

Deine Kommentare bzg. dem Wert von A0 und A1 passen so gar nicht.

[Paul (Gast)]

Es fehlen nur wenige Zeilen. In der kompletten Version stecken ca. 2 
Seiten mit auskommentierten Teilen.

#define F_CPU 8000000        // CPU clock in Hz

#include <avr/interrupt.h>  // dient zur Behandlung der Interrupts
#include <avr/io.h>         // Integer-Definitionen

#define I2C_DATA_INTERRUPT      0x80  // 0x80
#define I2C_BUS_COLLISION       0x08  // 0x08
#define I2C_ADDRESS_STOP_MATCH  0x40  // 0x40

volatile uint8_t command;
volatile uint8_t tx_buf[2];  // 4
volatile uint8_t tx_buff = 11;  // 4
volatile uint8_t tx_buf_index = 0;

#define Adress_1  0x22    // Slave Adresse 1
#define Adress_2  0x24    // Slave Adresse 2
#define Adress_3  0x26    // Slave Adresse 3
#define Adress_4  0x28    // Slave Adresse 1+2
#define Adress_5  0x30    // Slave Adresse 1+3
#define Adress_6  0x32    // Slave Adresse 2+3
#define Adress_7  0x34    // Slave Adresse 1+2+3
#define Adress_8  0x36    // Slave Adresse nicht 1+2+3

uint8_t I2C_SLAVE_ADDRESS;  

 #define S1 (1<<PINA1)
 #define S2 (1<<PINA2)

void auswahl_sw()
{
 uint8_t Schalter = PINA & (S1 | S2);

 switch (Schalter)
   {              // betrachtet die Eingangsmenge der Schalterstellung(en) von S1 und S2
     case  0:    I2C_SLAVE_ADDRESS = Adress_1;    // Adresse 0x22 A0 auf GND
       break;
     case S1:    I2C_SLAVE_ADDRESS = Adress_2;    // Adresse 0x24 A1 auf GND
       break;
     case S2:    I2C_SLAVE_ADDRESS = Adress_3;    // Adresse 0x36 bei A0 und A1 auf Vcc (offen)
       break;
     case S1|S2: I2C_SLAVE_ADDRESS = Adress_4;    // Adresse 0x28 A0 + A1 auf GND
       break;
   }
}

int main(void)
  {  
  DDRA=0b00000000;      // Port A auf Ausgang schalten
  PORTA=0b00000000;      // Port A auf aus 
  DDRB=0b00000011;      // Port A auf Ausgang schalten
  PORTB=0b00000011;      // Port A auf aus  
    
  auswahl_sw();
  I2C_init();
  
  
  while(1)
    {
    if (command != 42)           // Taster T2 PD0
     {                    // Wenn T1 gedrückt...
       PORTA &=~(1<<PINA1);        // LED 2 ein  
     }
     else
    {                    // wenn nicht
       PORTA |=(1<<PINA1);          // LED 2 ein ??
    }  
     if (command != 43)           // Taster T2 PD0
    {                    // Wenn T1 gedrückt...
      PORTA &=~(1<<PINA0);        // LED 2 aein
    }
     else
    {                    // wenn nicht  
      PORTA |=(1<<PINA0);          // LED 2 ein ??
    }   
    
    {
    
      {
        
        
    // ========>> TASTENEINGABEN T3
    if (!(PINA & (1<<PINA7)) )            // Taster T 3
      {                  // Wenn T3 gedrückt...
      tx_buff = 5;  // 4
      }
    
    // ========>> TASTENEINGABEN T2
    if (!(PINB & (1<<PINB2)) )            // Taster T 3
      {                  // Wenn T3 gedrückt...
      tx_buff = 3;  // 4
      }    
      }
    }   
    }
  }

Den Timer und den I2C init ist nicht drin. In der Version mit if 
funktioniert es ohne Probleme. A0 und A1 können nicht passen, da sie 
keine Pins bezeichnen sondern die Dip Schalter sind zum schalten der 
Adresse.
Bei dieser Hardware habe ich kein Display dran. Das Auslesen der I2C 
Adresse erfolgt mit dem Bus und wird am Master durch einen Bus Scanner 
angezeigt.

[Wolfgang (Gast)]

Paul schrieb:
> A0 und A1 können nicht passen, da sie
> keine Pins bezeichnen sondern die Dip Schalter sind zum schalten der
> Adresse.

Das meine ich nicht.

Es kann nicht sein, das die Variable Schalter den Wert 0 annimmt, wenn 
nur A0 auf Gnd liegt.
Genauso wenig kann es sein, das Schalter == S1|S2 wird, wenn A0 und A1 
auf Gnd liegen.

[Joachim B. (jar)]

Paul schrieb:
> #define Adress_1  0x22    // Slave Adresse 1
>
> switch (Schalter)
>    {              // betrachtet die Eingangsmenge der
> Schalterstellung(en) von S1 und S2
>      case  0:    I2C_SLAVE_ADDRESS = Adress_1;    // Adresse 0x22 A0 auf
> GND
>        break;

warum dass denn?
#define Adress_1  0x22    // Slave Adresse 1

ist doch sowas von unnötig, kannst auch gleich schreiben
case 0x22:    I2C_SLAVE_ADDRESS = 0x22;    // Adresse 0x22 A0 auf
break;
usw.

so mache ich das

#if (ARDUINO>0)
  DEBUG_PRINTLN(F(" -> Scanning..."));

#if defined (I2C_TASTATUR_8574) || defined (I2C_TASTATUR_8574A)
  char _i2c_key=0;
#endif
  byte error, address;
  int nDevices=0;
  for(address = 1; address < 127; address++ ) 
  { // The i2c_scanner uses the return value of
    // the Write.endTransmisstion to see if
    // a device did acknowledge to the address.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();

    if (error == 0)
    { DEBUG_PRINT(F("I2C device found at address 0x"));
      if (address<16) 
        DEBUG_PRINT(F("0"));
      DEBUG_PRINT_DEC_HEX(address,HEX);
      DEBUG_PRINT(F("; "));
      if (address<64) 
        DEBUG_PRINT(F("0"));
      DEBUG_PRINT_DEC_HEX(address,BIN);
      DEBUG_PRINT(F("x; << 0x"));
      DEBUG_PRINT_DEC_HEX((address<<1),HEX);
      DEBUG_PRINT(F("; "));
      if ((address<<1)<128) 
        DEBUG_PRINT(F("0"));
      DEBUG_PRINT_DEC_HEX((address<<1),BIN);
      
      switch(address<<1)
      {
        case 0x40:
#ifdef I2C_TASTATUR_8574
          i2c_test_flags|=(1<<I2C_TASTATUR_8574);
//          i2c_test_flags|=(1<<I2C_TASTATUR);
//          _i2c_key=' ';
#endif // #ifdef I2C_TASTATUR_8574
          DEBUG_PRINTLN(F(" PCF8574  Tastatur"));
          break;
        case 0x70:
#ifdef I2C_TASTATUR_8574A
          i2c_test_flags|=(1<<I2C_TASTATUR_8574A);
//          i2c_test_flags|=(1<<I2C_TASTATUR);
//          _i2c_key='A';
#endif // #ifdef I2C_TASTATUR_8574A
          DEBUG_PRINTLN(F(" PCF8574A Tastatur"));
          break;
        case 0xA0:
          DEBUG_PRINTLN(F(" I2C EEPROM       "));
          i2c_test_flags|=(1<<I2C_EEPROM);          
          break;
        case 0xD0:
          //Wire.beginTransmission(DS1307_ID);
          //printIIC(0x3F);
          /*(Wire.endTransmission()) ?*/ i2c_test_flags|=(1<<I2C_RTC_3231) /*: i2c_test_flags|=(1<<I2C_RTC_1307)*/;
          #ifdef DEBUG
          if(i2c_test_flags&(1<<I2C_RTC_3231)) 
            Serial.println(F(" DS3231 RTC "));
          #endif
          break;
        default:
          DEBUG_PRINTLN(F(""));
          break;
      }
      nDevices++;
    }
    else if (error==4) 
    { DEBUG_PRINT(F("Unknow error at address 0x"));
      if (address<16) 
        DEBUG_PRINT(F("0"));
      DEBUG_PRINTLN_DEC_HEX(address,HEX);
    }    
  }
  if (nDevices == 0)
    DEBUG_PRINTLN(F("No I2C devices found"));
  else
    DEBUG_PRINTLN(F("done"));
  DEBUG_PRINTLN(F(""));
#endif

muss nur erweitert werden auf alle möglichen switch Adressen

[Paul (Gast)]

Paul schrieb:
> switch (Schalter)
>    {              // betrachtet die Eingangsmenge der
> Schalterstellung(en) von S1 und S2
>      case  0:    I2C_SLAVE_ADDRESS = Adress_1;    // Adresse 0x22 A0 auf
> GND
>        break;
>      case S1:    I2C_SLAVE_ADDRESS = Adress_2;    // Adresse 0x24 A1 auf
> GND
>        break;
>      case S2:    I2C_SLAVE_ADDRESS = Adress_3;    // Adresse 0x36 bei A0
> und A1 auf Vcc (offen)
>        break;
>      case S1|S2: I2C_SLAVE_ADDRESS = Adress_4;    // Adresse 0x28 A0 +
> A1 auf GND
>        break;
>    }

Habe es so übernommen wie es als Hinweis von Peter und dir drin waren.
So wie du es schreibst geb ich dir Recht.
Wie kann ich es den besser machen?

[Eric B. (beric)]

Paul schrieb:
> Wie kann ich es den besser machen?

Angenommen die DIP-switches liegen an PINA2, PINA1 und PINA0:

uint8_t i2c_addresses[] = {
  //       A2|A1|A0 - DIP switches
  0x22, //  0  0  0        0 = GND
  0x24, //  0  0  1        1 = Vcc
  0x26, //  0  1  0
  0x28, //  0  1  1
  0x30, //  1  0  0
  0x32, //  1  0  1
  0x34, //  1  1  0
  0x36, //  1  1  1
};

void auswahl_sw()
{
  I2C_SLAVE_ADRESS = i2c_addresses[PINA & 0x07];
}

Und sicher stellen, dass du auch wirklich diese Pins benutzt! Deine 
Kommentare und der Code widersprechen sich (A0/A1 vs A!/A2).
Und wie willst du an diesen Portpins (A0-A2) sowohl die switches 
auslesen als auch gleichzeitig eine LED leuchten lassen?

[Paul (Gast)]

Eric B. schrieb:
> Und wie willst du an diesen Portpins (A0-A2) sowohl die switches
> auslesen als auch gleichzeitig eine LED leuchten lassen?

Hast du da was verwechselt?
Ich verwende nur die PINS PA1 - A0, PA2 - A1, PA2 - A2 als Eingang. 
Dabei sind A0, A1 und A2 die Dip Schalter auf der Platine um die I2C 
Adresse einzustellen. PA1, PA2 und PA3 sind die Pins am Attiny 841 und 
werden nur als Eingang benutzt, nicht als Ausgang. Dabei sind die PINS 
PA1, PA2 und PA2 mit Widerständen nach Vcc (5V) gelegt und werden durch 
die Dips auf GND gelegt und sollen damit erkannt werden.
Weiter oben habe ich den Code drin, mit if (..). der sehr gut 
funktioniert. Auf Vorschlag von Peter wollte ich das ganze nocht mit 
switch machen, da es einfacher sein soll (wenn es funktioniert).
LG Paul

[Wolfgang (Gast)]

Paul schrieb:
> Wie kann ich es den besser machen?

Die Kommentare passen nicht zum Wert von der Variablen Schalter (case 
..)
Den I²C-Adressen geht es meglicherweise nicht besser, je nachdem, ob 
deine Erwartungshalten sich auf den Programmcode oder auf die Kommentare 
stützt.

[Paul (Gast)]

Noch mal, die Bezeichnungen A0, A1 und A2 beziehen sich nur auf die Dip 
Schalter um die Adressen einzustellen. Das wird auch bei anderen ICs 
verwendet z.B. PCF usw. Diese Bezeichnzngen haben nichts mit den 
Eingangspins oder Ports zu tun.
Habe es jetzt auf 3 Dip Schalter erweitert und noch mal alle 
Kombinationen durchgestet. Dabei ist das rausgekommen.

#define S1 (1<<PINA1)
 #define S2 (1<<PINA2)
 #define S3 (1<<PINA3)

void auswahl_sw()
  {
    uint8_t Schalter = PINA & (S1 | S2 | S3);
    switch (Schalter)
      {              // betrachtet die Eingangsmenge der Schalterstellung(en) von S1 und S2 und S3
      case  0:    I2C_SLAVE_ADDRESS = Adress_1;    // Adresse 0x22, A0 und A1 und A2 auf GND, keiner offen
        break;
      case S1:    I2C_SLAVE_ADDRESS = Adress_2;    // Adresse 0x24, A1 und A2 auf GND, A1 offen
        break;
      case S2:    I2C_SLAVE_ADDRESS = Adress_3;    // Adresse 0x26, A0 und A2 auf GND, A1 offen
        break;
      case S3:    I2C_SLAVE_ADDRESS = Adress_4;    // Adresse 0x28, A0 und A1 auf GND, A2 offen
        break;
      case S1|S2:    I2C_SLAVE_ADDRESS = Adress_5;    // Adresse 0x30, A2 auf GND, A0 + A1 offen 
        break; 
      case S2|S3:    I2C_SLAVE_ADDRESS = Adress_6;    // Adresse 0x32, A0 und A1 auf GND, A1 + A2 offen
        break;
      case S1|S3:    I2C_SLAVE_ADDRESS = Adress_7;    // Adresse 0x34, A1 auf GND, A0 und A2 offen
        break;      
      case S1|S2|S3: I2C_SLAVE_ADDRESS = Adress_8;    // Adresse 0x36, A0 + A1 + A2 auf Vcc, alle offen
        break;
      }
  }

wenn ich mir die Busadressen dabei anschaue, sind sie nur verkehrt herum 
(negiert).
Einfach die Schalter negieren?

[Eric B. (beric)]

Paul schrieb:
> Ich verwende nur die PINS PA1 - A0, PA2 - A1, PA2 - A2 als Eingang.

Und auch un die LEDs anzusteuern. In deiner main()-Funktion steht doch:

Paul schrieb:
> if (command != 42)           // Taster T2 PD0
>      {                    // Wenn T1 gedrückt...
>        PORTA &=~(1<<PINA1);        // LED 2 ein
>      }
>      else
>     {                    // wenn nicht
>        PORTA |=(1<<PINA1);          // LED 2 ein ??
>     }
>      if (command != 43)           // Taster T2 PD0
>     {                    // Wenn T1 gedrückt...
>       PORTA &=~(1<<PINA0);        // LED 2 aein
>     }
>      else
>     {                    // wenn nicht
>       PORTA |=(1<<PINA0);          // LED 2 ein ??
>     }

[Paul (Gast)]

Dein zitierter Teil ist vollkommen falsch. Es stammt aus einem anderen 
Programm und wird hier überhaupt nicht(mehr) verwendet. Es geht hierbei 
nur um die Abfrage der gesetzten Dip Schalter um die I2C Bus Adresse zu 
erkennen.
Hatte aber mehrfach darauf hingewiesen.