Avisaro WLAN Modul I2C

Hallo,

ich bin gerade etwas am verzweifeln, möchte ein Avisaro Wlan Modul per I2c ansprechen.

Ich benutze die I2C Bibliothek in TWI Form von P. Fleury

Ich kann problemlos auf einen PCF8574 verbinden.

Problem ist ich bekomme keine Verbindung. Ich habe über ein LED-Blinken herausbekommen, dass ich bis zum absenden der I2C-Adresse komme und dann gehts nicht weiter :-(

Bitte um Hilfe

Hier mein Code:

Code:

---


char buffi[20];

int main(void) {

DDRC = 0xFF;
PORTC = 0x00;

i2c_init();       

Delay(4000);

I2cRead(73, 5);
// I2cSend(73, 5);

}

---

Code:

---


// *** Kommunikationsfunktion ***

uint8_t I2cRead(uint8_t device, uint16_t how_much) {

        uint16_t size;
        uint8_t w = 0;               
       
//  *** LED blinken lassen ***
        PORTD |= (1<<DDD2);       
        Delay(1000);
        PORTD &= ~(1<<DDD2);
               
        i2c_start(device<<1 | 1);

//  *** LED blinken lassen ***
  Delay(400);
        PORTD |= (1<<DDD2);       
        Delay(100);
        PORTD &= ~(1<<DDD2);
        Delay(400);

// -> Bis hier hin gehts size = i2c_readAck(); läuft sich tot

        size = i2c_readAck();

//  *** LED blinken lassen ***
  Delay(400);
        PORTD |= (1<<DDD2);       
        Delay(100);
        PORTD &= ~(1<<DDD2);
        Delay(400);
       
        size <<= 8;
       
        size |= i2c_readAck();
       
//  *** LED blinken lassen ***
        Delay(400);
        PORTD |= (1<<DDD2);       
        Delay(100);
        PORTD &= ~(1<<DDD2);
        Delay(400);
       
        if (size == 0 || size == 0xffff) {

        } else {
                while (size && how_much){
                        if (size == 1 || how_much == 1) {
                                buffi[w] = (uint8_t) i2c_readNak;
                        } else {
                                buffi[w]  = (uint8_t) i2c_readAck;
                        }
                        // Alle Zähler und Pointer weiterzählen
                        w++;
                        cnt++;
                        size--;
                        how_much--;
                }
        }

        i2c_stop();
       
        return 0;
}

uint8_t I2cSend(uint8_t device, uint8_t data) {
        ...
}

---

Ok ich kann das Modul jetzt über I2C ansprechen, jedoch kommen nur komische zeichen bei dem i2c_readAck in der whileschleife raus, z.B. ö und das fortlaufend

ich habe mir mal die variable size ausgeben lassen und da steht immer die 74 drin, sieht nach der adresse des moduls aus auf der es liest, kann das nicht wirklich deuten :-(

Bitte um Hilfe

Code:

---


int main(void) {

        uint16_t size;
        uint16_t how_much = 10;
        uint8_t device = 73+I2C_READ;

        DDRC = 0xFF;
        PORTC = 0x00;


        PORTD &= ~(1<<DDD2);
        Delay(1000);
       
        // *** Diode blinken lassen ***
        PORTD |= (1<<DDD2);       
        Delay(400);
        PORTD &= ~(1<<DDD2);
       
        CursorVisual(1);
        ClearLcd();
        UsartTx('>');
        UsartPrint((uint8_t *) "Entwicklermodus    ", 19);
       
        Delay(4000);
       
        PORTD |= (1<<DDD2);       
        Delay(1000);
        PORTD &= ~(1<<DDD2);
               
        i2c_start(device);
       
  Delay(400);
        PORTD |= (1<<DDD2);       
        Delay(100);
        PORTD &= ~(1<<DDD2);
        Delay(400);
       
        size = (uint16_t) i2c_readAck();
       

  Delay(400);
        PORTD |= (1<<DDD2);       
        Delay(100);
        PORTD &= ~(1<<DDD2);
        Delay(400);
       
        size <<= 8;
       
        size |= i2c_readAck();

        char zahlausgabe[sizeof(size)] ;
        sprintf(zahlausgabe,"%i",size);
        UsartPrint((uint8_t *) zahlausgabe,strlen(zahlausgabe));
        Delay(10000);
       
       
        Delay(400);
        PORTD |= (1<<DDD2);       
        Delay(100);
        PORTD &= ~(1<<DDD2);
        Delay(400);
       

       
        if (size == 0 || size == 0xffff) {

        } else {
                while (size && how_much){
                        if (size == 1 || how_much == 1) {
                                Delay(400);
                                PORTD |= (1<<DDD2);       
                                Delay(100);
                                PORTD &= ~(1<<DDD2);
                                Delay(400);
                                //buffi[w] = i2c_readNak;
                                UsartTx(i2c_readNak);
                        } else {
                                //buffi[w] = i2c_readAck;
                                UsartTx(i2c_readAck);
                        }
                        // Alle Zähler und Pointer weiterzählen
                        //w++;
                        //dest++;
                        //cnt++;
                        size--;
                        how_much--;
                }
        }

        i2c_stop();

---

Ich versteh eine sache nicht in der P. Fleury Bibliothek werden die I2C Adressen mit der Syntax

(adresse + I2C_READ);

zusammengestellt

in der doku des Avisaro moduls steht jedoch das die Adressen so zusammengestellt werden

(address<<1 | 1);

also wenn ich diese zwei verfahren nehme bekomme ich zwei verschiedene zahlen raus. Nehmen wir z.B. 73 dann bekomme ich fürs erste verfahren 74 raus da I2C_READ mit 1 definiert ist, und für das zweite verfahren mit dem shift 149 raus.

Ich werd langsam verrückt...

](*,) ](*,) ](*,) ](*,)

Hallo,

die Adresse bei I2C ist ja 7 Bit groß, wobei diese im oberen Bereich eines Bytes liegen, je nach Geschmack wird so eine Adresse dann als 7 Bit Zahl angegeben, wie hier die 73, oder als 8 Bit Wert, wäre es die 146.
Das 1. Bit gibt an ob man vom Slave was lesen (1) oder schreiben (0) will.

Wenn nun bei Avisaro angegeben ist, das die Adresse 73 ist und die mit <<1 umzurechnen ist, musst Du das auch vorher machen. Oder besser gleich die 146 angeben, damit es bei der Lib passt.

Ob man das Schreib/Lesebit mit + oder | (oder) verknüpft ist bei richtiger BasisAdressenwahl egal. (Auf der sicheren Seite ist man mit der | Version)

Bei diesem Modul ist dann die 146 oder Hex $92 die Basisadresse für das schreiben zum Slave. Zum lesen wird es die 147, bzw. $93.

Schau mal die Artikel dazu im Wiki durch, da steht auch wie das mit der Adresse funktioniert !

Also momentan komme ich nicht weiter :-( Ich bekomme anscheinend kein ack vom modul. Ich habe markiert an welcher stelle die i2c_start funktion verlassen wird.

Es ist alles richtig verlötet (leitungen und kabel sind geprüft) und die Adressierung stimmt auch.

Einstellungen am Modul sind 100kHz für den Takt ohne flusskontrolle pullups im modul sind auch eingeschaltet.

Code:

---

unsigned char i2c_start(unsigned char address)
{
    uint8_t  twst;

        // send START condition
        TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);

        // wait until transmission completed
        while(!(TWCR & (1<<TWINT)));


        // check value of TWI Status Register. Mask prescaler bits.
        twst = TW_STATUS & 0xF8;
        if ( (twst != TW_START) && (twst != TW_REP_START)) return 1;


        // send device address
        TWDR = address;
        TWCR = (1<<TWINT) | (1<<TWEN);

        // wail until transmission completed and ACK/NACK has been received
        while(!(TWCR & (1<<TWINT)));


        // check value of TWI Status Register. Mask prescaler bits.
        twst = TW_STATUS & 0xF8;

// An dieser Stelle springt er immer aus der funktion (mit dem return 1)

        if ( (twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK) ) return 1;


        return 0;

}/* i2c_start */

---

Das bedeutet, da sich der Slave nicht auf die gesendete Adresse meldet.
Welche Adresse hast Du nun beim Start mitgegeben (0x92) ?

Sind auch die Massen verbunden, nicht das das Modul nix mitbekommt ?

Ohh man! Die Massefalle mal wieder, das wars vielen Dank!!! Drei Tage um sonst verschwendet... ](*,)