ESP32 Treiber für I2C Display AiP31068L ardiuno.h wire.h

OP #7791749
Lesenswert?

Hallo zusammen,

ich arbeite derzeit an der Entwicklung eines Treibers für ein LCD-Display mit einem AiP31068L Controller. Dieses Display ist über I²C mit einem ESP32 verbunden. Mein Ziel ist es, das Busy-Flag und den Address Counter auszulesen. Laut Dokumentation erfordert das Protokoll folgende Schritte: Protokoll für Busy-Flag-Auslese:

  1. Start Condition (S): Der Master startet die Kommunikation.
  2. Slave-Adresse senden (R/W=1): Die 7-Bit-Adresse des Slaves wird gesendet, gefolgt von einem Lese-Bit (R/W=1).
  3. Leeres Byte (Control Byte) senden (0x00): Der Master sendet ein einzelnes Byte mit dem Wert 0x00.
  4. Lehres Byte (Data Byte) senden (0x00). Da bin ich mir nicht ganz sicher.
  5. Stop Condition (P): Der Master beendet die Kommunikation.
  6. Data Byte Lesen aber wie???

Auf der Seite 11 wird das Protokoll beschrieben, aber leider nur ein Schreibvorgang. Ich besitzte auch einen Logic Analyzer, somit kann ich das Signal beobachten. Daher meine Frage: Wie muss das Protokoll aufgebaut werden, damit ein Lesevorgang durchgeführt werden kann?

Das oben beschrieben Protokoll kann soweit ich es jetzt herausgefunden habe nicht mit der arduino wire lib umgesetzt werden. Siehe: https://docs.espressif.com/projects/arduino-esp32/en/latest/api/i2c.html#i2c-write

1
Ablauf 1:
2
Wire.begin(); <-- Init Hardware
3
Wire.beginTransmission(I2C_DEV_ADDR); <-- Buffer index reset, txadresse wird gesetzt
4
Wire.write(x); <-- tx buffer füllen
5
Wire.endTransmission(); <-- startet den i2c stream

Bei Ablauf 1 wird die Adresse um ein bit nach links verschoben und das LSB (R/W) bit wird immer auf 0 gesetzt.

1
Ablauf 2:
2
Wire.requestFrom(I2C_DEV_ADDR, SIZE); <-- sendet i2c adresse mit (R/W=1) bit. 
3
Wire.readBytes(temp, error);

Kann ich mit der arduino wire lib dieses Protokoll für eine Lesevorgang überhaut aufbauen?

Anbei mein Code und die I2c Daten als Bild:

1
#define _PIN_DEBUG_CH4 4  ///< GPIO pin for debug with logic analyzer
2
#define _PIN_DEBUG_CH5 5  ///< GPIO pin for debug with logic analyzer
3
#define _PIN_DEBUG_CH6 6  ///< GPIO pin for debug with logic analyzer
4
#define _PIN_DEBUG_CH7 7  ///< GPIO pin for debug with logic analyzer
5

6

7
#include <Wire.h>
8

9
#define _LCD_ADDRESS 0x7C >> 1  // 7-Bit-Adresse des AiP31068L
10

11
class AIP31068L {
12
private:
13
  uint8_t lcdAddress;  // Interne Variable zur Speicherung der Adresse
14

15
public:
16
  AIP31068L(uint8_t address) {
17
    lcdAddress = address;
18
  }
19

20
  void write() {
21
    uint8_t controlByte;
22
    uint8_t dataByte;
23
    uint8_t error;
24
    controlByte = 0x00;
25
    dataByte = 0x00;
26

27
    Wire.beginTransmission(lcdAddress);
28
    Wire.write(controlByte);
29
    Wire.write(dataByte);
30
    error = Wire.endTransmission(true);
31

32
    if (error != 0) {
33
      Serial.println("Fehler: Übertragung fehlgeschlagen");
34
    }
35
  }
36

37
  void read() {
38
    Wire.requestFrom(lcdAddress, 2, true);
39
  }
40
};
41

42
AIP31068L lcd(_LCD_ADDRESS);
43

44
void setup() {
45
  Serial.begin(115200);
46

47
  pinMode(_PIN_DEBUG_CH4, OUTPUT);
48
  pinMode(_PIN_DEBUG_CH5, OUTPUT);
49
  pinMode(_PIN_DEBUG_CH6, OUTPUT);
50
  pinMode(_PIN_DEBUG_CH7, OUTPUT);
51

52
  digitalWrite(_PIN_DEBUG_CH4, LOW);
53
  digitalWrite(_PIN_DEBUG_CH5, LOW);
54
  digitalWrite(_PIN_DEBUG_CH6, LOW);
55
  digitalWrite(_PIN_DEBUG_CH7, LOW);
56

57

58
  digitalWrite(_PIN_DEBUG_CH4, HIGH);
59
  Wire.begin();
60
  digitalWrite(_PIN_DEBUG_CH4, LOW);
61

62
  digitalWrite(_PIN_DEBUG_CH5, HIGH);
63
  lcd.write();
64
  digitalWrite(_PIN_DEBUG_CH5, LOW);
65

66
  digitalWrite(_PIN_DEBUG_CH6, HIGH);
67
  lcd.read();
68
  digitalWrite(_PIN_DEBUG_CH6, LOW);
69
}
70

71
void loop() {
72
}
Angehängte Dateien:
#7791991
Lesenswert?

Kevin H. schrieb:

Auf der Seite 11 wird das Protokoll beschrieben, aber leider nur ein Schreibvorgang.

Das ist I2C, wo ist das Problem?

Sieh Dir an, wie z.B. mit einem seriellen EEPROM (à la 24C01) kommuniziert wird, oder sonst irgendeinem anderen I2C-Baustein.

Da gibt es in der Arduino-Welt zigtausend Beispiele, wie mit "wire" geht.

Z.B. hier: https://fritzing.org/projects/readwrite-serial-eeprom-via-i2c

OP #7792211
Lesenswert?

Danke für deine Antwort. Ich habe mir den Artikel von deinem Link angeschaut. Allerdings gibt es die Methode send nicht bei der ESP32 wire.h lib. Ich denke bei der ESP32 lib heißt diese write. Nachdem Write befehl bekomme ich als Byte ein 0xFF. Dies sieht man auch im Bild. Und dies erscheint mir Mekrwürdig.

Du hast aber nur sehr oberflächlich geantwortet und mir damit nicht geholfen.

Kannst du meine 2 Fragen konkret beantworten? Wie muss das Protokoll aufgebaut werden, damit ein Lesevorgang durchgeführt werden kann? Da ich es aus der Doku nicht vollständig verstehe und selbst noch nicht mit I2C so im Detail gearbeitet habe.

Kann ich mit der arduino wire lib dieses Protokoll für eine Lesevorgang überhaut aufbauen?

#7792439
Lesenswert?

Normalerweise sendest du die Slaveadresse & Register das du lesen willst, danach einen Lesevorgang mit der Slaveadresse und der Variablen, die dein gelesenes Register enthalten soll.

In meiner Welt wäre das dann TWIOut($7C,$00); //wenn $00 die zu lesende Registernummer ist TWIInp($7C,Reg);

Wobei

Var Reg : Byte;

Zeig mal ein Foto des Displays 🙂

#7792536
Lesenswert?

Kevin H. schrieb:

Du hast aber nur sehr oberflächlich geantwortet und mir damit nicht geholfen.

Ich habe Dir einen deutlichen Hinweis gegeben, wie Du Dir selbst helfen kannst.

Wenn der Arduino-Code, den ich Dir verlinkt habe, bei Deiner Variante nicht verwendbar ist, könntest Du (und ich hatte gehofft, daß Du das Prinzip verstehst) nach der Kombination "ESP32 Arduino 24c01" suchen.

Gib einem Hungrigen einen Fisch, und er ist einen Moment lang satt. Gib ihm eine Angel ...

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren