BH1750 per I²C an ATmega32 - low Byte immer nur 255

[Matthias S. (matze11)]

Hallo!

Ich möchte einen Lichtsensor über die I²C-Schnittstelle auslesen.
Der BH1750 liefert einen 16-Bit Messwert, wobei zuerst das high-Byte
und dann das low-Byte übertragen wird.

Das high-Byte kann ich verarbeiten, das low-Byte ist hingegen aber
immer nur 255. Auf dem Oszilloskop sieht es auch so aus, als dass
der Wert nur mit 255 übertragen wird.

Ich vermute, dass ich einen Fehler mit der I²C-Schnittstelle im Bereich 
ack/nack habe. Hat von euch vielleicht jemand eine Idee, warum das so 
nicht funktioniert?

Anbei das Datenblatt in dem auf Seite 7 unten das Übertragungsschema 
gezeigt ist.

Danke im Voraus!

Gruß,
Matze

P.S.: Die I²C-Funktionen stammen nicht von mir.

#define F_CPU 16000000UL

#include<avr/io.h>
#include<util/delay.h>
#include<inttypes.h>
#include "lcd4b.h"
#include <stdint.h>                      // für my_uitoa(uint32_t zahl, char* string)

void my_uitoa(uint32_t zahl, char* string);
void TWI_start(void);
void TWI_repeated_start(void);
void TWI_init_master(void);
void TWI_write_address(unsigned char);
void TWI_read_address(unsigned char);
void TWI_write_data(unsigned char);
void TWI_read_data(void);
void TWI_stop(void);

#define consthigh 0b00010000  // Betrieb mit 1 Lux Auflösung
#define constlow 0b00100011    // Betreib mit 4 Lux Auflösung
#define adr_wr 0b01000110    // Adresse mit r/w-Bit auf schreiben
#define adr_rd 0b01000111    // Adresse mit r/w-Bit auf lesen

unsigned recv_data;      

int main(void)
{
  DDRA |= 0b11111100;      //Pins 2-7 als Ausgänge //Jumper DB4-DB7 (der Rest raus)), RS auf PA2, E auf PA3, R/W auf GND,  
  char text[3];
  char high;
  char low;
  unsigned int ergebnis=0;

  lcd_linit();
  lcd_clear();
  TWI_init_master();  

  while(1)
  {  
    TWI_start();          // Startbedingung senden
    TWI_write_address(adr_wr);    // Adresse und Datenrichtung=schreiben senden

    TWI_write_data(constlow);    // Messung auslösen
    TWI_stop();            // Stoppbedingung senden
    
    _delay_ms(24);          // Messung abwarten
    
    TWI_start();
    TWI_read_address(adr_rd);    // Adresse und Datenrichtung=lesen senden
    TWI_read_data();        // Daten empfangen
    high=recv_data;
    TWI_read_data();        // Daten empfangen  
    TWI_stop();
    low=recv_data;  

    lcd_clear();
    
    itoa(low,text,10);
    lcd_command(line1);
    lcd_out(text);
    
    itoa(high,text,10);
    lcd_command(line2);
    lcd_out(text);
    
    _delay_ms(100);
  }
}

void TWI_init_master(void) // Function to initialize master
{
  TWBR=0xFF; // Bit rate
  TWSR=(0<<TWPS1)|(0<<TWPS0); // Setting prescalar bits
  // SCL freq= F_CPU/(16+2(TWBR).4^TWPS)
}

void TWI_start(void)
{
  // Clear TWI interrupt flag, Put start condition on SDA, Enable TWI
  TWCR= (1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
  while(!(TWCR & (1<<TWINT))); // Wait till start condition is transmitted
  while((TWSR & 0xF8)!= 0x08); // Check for the acknowledgement
}

void TWI_repeated_start(void)
{
  // Clear TWI interrupt flag, Put start condition on SDA, Enable TWI
  TWCR= (1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
  while(!(TWCR & (1<<TWINT))); // wait till restart condition is transmitted
  while((TWSR & 0xF8)!= 0x10); // Check for the acknoledgement
}

void TWI_write_address(unsigned char data)
{
  TWDR=data; // Address and write instruction
  TWCR=(1<<TWINT)|(1<<TWEN);    // Clear TWI interrupt flag,Enable TWI
  while (!(TWCR & (1<<TWINT))); // Wait till complete TWDR byte transmitted
  while((TWSR & 0xF8)!= 0x18);  // Check for the acknoledgement
}

void TWI_read_address(unsigned char data)
{
  TWDR=data; // Address and read instruction
  TWCR=(1<<TWINT)|(1<<TWEN);    // Clear TWI interrupt flag,Enable TWI
  while (!(TWCR & (1<<TWINT))); // Wait till complete TWDR byte received
  while((TWSR & 0xF8)!= 0x40);  // Check for the acknoledgement
}

void TWI_write_data(unsigned char data)
{
  TWDR=data; // put data in TWDR
  TWCR=(1<<TWINT)|(1<<TWEN);    // Clear TWI interrupt flag,Enable TWI
  while (!(TWCR & (1<<TWINT))); // Wait till complete TWDR byte transmitted
  while((TWSR & 0xF8) != 0x28); // Check for the acknoledgement
}

void TWI_read_data(void)
{
  TWCR=(1<<TWINT)|(1<<TWEN);    // Clear TWI interrupt flag,Enable TWI
  while (!(TWCR & (1<<TWINT))); // Wait till complete TWDR byte transmitted
  while((TWSR & 0xF8) != 0x58); // Check for the acknoledgement
  recv_data=TWDR;

}

void TWI_stop(void)
{
  // Clear TWI interrupt flag, Put stop condition on SDA, Enable TWI
  TWCR= (1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
  while(!(TWCR & (1<<TWSTO)));  // Wait till stop condition is transmitted
}

[Manuel H. (manu77)]

Matthias S. schrieb:
> Ich vermute, dass ich einen Fehler mit der I²C-Schnittstelle im Bereich
> ack/nack habe.

Ich kann dir da nur einen Logik-Analyser empfehlen, ohne mich jetzt in 
deinen Code eingelesen zu haben. Das geht am schnellsten.

[Patrick C. (pcrom)]

Zum fehlersuchen im I2C routinen ist es oft eine gute idee um zu testen 
mit ein PCF8574 chip, einfach 8 bits in/out.

Dabei ist es auch eine gute idee an zu fangen mit ein scan auf alle 
moeglichte i2c adresse (0x10-0xEE step 2) zum gucken ob da ein chip 
antwortet. Damit weisz man ob die gute adresse gewahlt ist und ob die 
ACK/NACK abhandlung gut funktioniert.

Oft passiert es das die 7/8 bit adressierung nicht gut eingestellt wird.

Patrick

[Matthias S. (matze11)]

Hallo,

@Manuel: ich glaube nen Logik-Analysator lohnt sich bei mir nicht. :-)
@Patrick: ich habe leider kein anderes I²C-Bauteil zur Hand...

ich hoffe, dass jemand einfach das schon einmal mit einem 16-Bit-Wert 
gemacht hat. An sich ist es doch eine Standardanwendung, ich kenne mich 
bloß nicht mit der I²C und den entsprechenden Registern aus.

Hier noch einmal der Übertragungsrahmen:

Daten:         ST - Adr.+r/w - ACK - h. Byte - ACK - l. Byte - nACK - SP
Master/Slave:  (M)    (M)      (S)      (S)    (M)     (S)      (M) 
(M)

Vielleicht fällt jemanden ja noch etwas ein.

Gruß,
Matze

[Karl H. (kbuchegg)]

Matthias S. schrieb:

> Ich vermute, dass ich einen Fehler mit der I²C-Schnittstelle im Bereich
> ack/nack habe.


?
Du unterscheidest ja gar nicht zwischen ACK und NAK.

Nachdem du das erste Byte gekriegt hast, bestätigst du mit einem NAK. 
Was für das andere Device bedeutet "Jetzt kommt nichts mehr, bzw. ich 
brauch nichts mehr liefern, jetzt kommt nur noch der Stop"

Sieh dir mal die Funktionen von Peter Fleury an. Da gibt es nicht ohne 
Grund 2 Funktionen

/*************************************************************************
 Read one byte from the I2C device, request more data from device 
 
 Return:  byte read from I2C device
*************************************************************************/
unsigned char i2c_readAck(void)
{
  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA);
  while(!(TWCR & (1<<TWINT)));    

    return TWDR;

}/* i2c_readAck */


/*************************************************************************
 Read one byte from the I2C device, read is followed by a stop condition 
 
 Return:  byte read from I2C device
*************************************************************************/
unsigned char i2c_readNak(void)
{
  TWCR = (1<<TWINT) | (1<<TWEN);
  while(!(TWCR & (1<<TWINT)));
  
    return TWDR;

}/* i2c_readNak */

Nur für das letzte von dir erwartete Byte benutzt du die Funktion 
i2c_readNak. Alle anderen dazwischen liegenden Reads werden mit 
i2c_readAck abgewickelt.

[Manuel H. (manu77)]

Matthias S. schrieb:
> @Manuel: ich glaube nen Logik-Analysator lohnt sich bei mir nicht. :-)

Da reicht der Billige. Z.B. 
http://www.amazon.de/Saleae-Analyzer-8Channel-saleae-support/dp/B00EEWBPU4/ref=sr_1_3?ie=UTF8&qid=1444810150&sr=8-3&keywords=logic+analyser

[Matthias S. (matze11)]

Hallo Karl Heinz,

danke für den wertvollen Tipp!
Ich habe jetzt den Inhalt der beiden Funktionen
von Perter Fleury in meine Funktionen gepackt und
entsprechend angepasst.

Kaum zu glauben aber das Ganze funktioniert einwandfrei. ;-)

Habe vielen Dank für deine Hilfe!

Lieben Gruß,
Matze