I2C MCP4725 Wert Übertragen

[Michael H. (h_m)]

Guten Tag,

ich möchte gerne einen Wert in das Register des DAC MCP4725 schreiben. 
Zu Anfang 0V also 0x00.

Aber irgendwie bekomme ich das nicht hin wie ich das gerade versuche und 
mir vorstelle habe ich in den Header von nachfolgendem Code geschrieben.

Vielleicht kann mir bitte jemand behilflich sein das ich zumindest mal 
etwas übertragen kann. Denn ich bin I2C Anfänger

/*
 * MCP4725_DAC.c
 *
 * Created: 28.02.2019 09:11:19
 * Author : USER
 *
 * hier soll ein Wert mit I2C in das Register des DAC MCP4725 geschrieben werden, dieser soll dann eine Spannung
 * an Vout ausgeben. Ich Stelle mir das in der Whileschleife so vor 
 *
 * 1. Startbedingung Senden
 * 2. Übertragung der Adresse des MCP4725 (hier 11000000) + Write + ACK    Adresse A0 ist auf GND gelegt
 * 3. Übertragen des Wertes der in das Register geschrieben werden soll mit MT_DATA_ACK 0x00 
 * 4. Stopbedingung Senden jetzt soll der DAC soll 0V ausgeben
 * 
 * 
 * Ein möglicher Übertragungsfehler (ERROR) wird durch eine LED an PB1 angezeigt
 *
 * CPU: ATmega88, FCPU = 16MHz
 * die nachfolgende Rechnung mit 62,5kHz wurde mit 8Mhz berechnet, das habe ich noch nicht verstanden wie dies funktioniert
 * I²C CLK Frequency = 62,5kHz, --> CLK Frequency = FCPU/(16 + 2*(TWBR)*Prescaler Value)
 */
#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>

#define START           0x08    // A START condition has been transmitted
#define R_START         0x10    // A REPEATED START condition has been transmitted
#define SLA_W           0xC0    // Slave Address & Write 1100 0000 A0 ist auf GND gelegt
#define SLA_R           0xC1    // Slave Address & Read 1100 0001
#define MT_SLA_ACK      0x18    // Master Transmit SLA + W has been transmitted & ACK has been received
#define MT_DATA_ACK     0x00    // Master Transmit Data byte has been transmitted & ACK has been received
#define MR_SLA_ACK      0x40    // Master Receive SLA + R has been transmitted & ACK has been received
#define MR_SLA_NACK     0x48    // Master Receive SLA + R has been transmitted & ACK has been received
#define MR_DATA_ACK     0x50    // Master Receive Data byte has been transmitted & ACK has been returned
#define MR_DATA_NACK    0x58    // Master Receive Data byte has been transmitted & NACK has been returned
#define BIT_RATE        56      // Set value for the bit rate register TWBR

void ERROR(void);               // Prototyping of function "ERROR"

/*** Function to send a START Condition ***/
void TWI_START(void)
{
  // Send a START condition
  TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
  // Wait for TWINT Flag set. This indicates that the START condition has been transmitted
  while (!(TWCR & (1<<TWINT)));
  // Check value of TWI statusregister. Mask prescaler bits. If status different from START go to ERROR if ((TWSR & 0xF8) != START)
  ERROR();
}

/*** Function to send the Slave Address with ACK in Master Transmit Mode ***/
void TWI_MT_SLA_ACK(void)
{
  // Load Slave Address + Write into TWDR Register
  TWDR = SLA_W;
  // Clear TWINT bit in TWCR to start transmission
  TWCR = (1<<TWINT) | (1<<TWEN);
  // Wait for TWINT Flag set. This indicates that the SLA+W has been transmitted, and ACK/NACK has been received.
  while (!(TWCR & (1<<TWINT)));
  // Check value of TWI status register. Mask prescaler bits. If status different from MT_SLA_ACK go to ERROR
  if ((TWSR & 0xF8) != MT_SLA_ACK)
  ERROR();
}

/*** Function to send 8Bit of data with ACK in Master Transmit Mode **/
void TWI_MT_DATA_ACK(uint8_t data)
{
  // Load DATA into TWDR register
  TWDR = data;
  // Clear TWINT bit in TWCR to start transmission
  TWCR = (1<<TWINT) | (1<<TWEN);
  // Wait for TWINT flag set. This indicates that the DATA has been transmitted, and ACK/NACK has been received.
  while (!(TWCR & (1<<TWINT)));
  // Check value of TWI status register. Mask prescaler bits. If status different from MT_DATA_ACK go to ERROR
  if ((TWSR & 0xF8) != MT_DATA_ACK)
  ERROR();
}

/*** Function to send a REPEATED START condition **/
void TWI_R_START(void)
{
  // Send a START condition
  TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
  // Wait for TWINT Flag set. This indicates that the START condition has been transmitted
  while (!(TWCR & (1<<TWINT)));
  // Check value of TWI statusregister. Mask prescaler bits. If status different from R_START go to ER-ROR
  if ((TWSR & 0xF8) != R_START)
  ERROR();
}

/*** Function to send the Slave Address in Master Receive Mode with Acknowledge **/
void TWI_MR_SLA_ACK(void)
{
  // Load Slave Address + Read into TWDR Register
  TWDR = SLA_R;
  // Clear TWINT bit in TWCR to start transmission
  TWCR = (1<<TWINT) | (1<<TWEA) | (1<<TWEN);
  // Wait for TWINT Flag set. This indicates that the SLA+W has been transmitted, and ACK/NACK has been received.
  while (!(TWCR & (1<<TWINT)));
  // Check value of TWI status register. Mask prescaler bits. If status different from MR_SLA_ACK go to ERROR
  if ((TWSR & 0xF8) != MR_SLA_ACK)
  ERROR();
}

/*** Function to send the Slave Address in Master Receive Mode without Acknowledge **/
void TWI_MR_SLA_NACK(void)
{
  // Load Slave Address + Read into TWDR Register
  TWDR = SLA_R;
  // Clear TWINT bit in TWCR to start transmission
  TWCR = (1<<TWINT) | (1<<TWEN);
  // Wait for TWINT Flag set. This indicates that the SLA+W has been transmitted, and ACK/NACK has been received.
  while (!(TWCR & (1<<TWINT)));
  // Check value of TWI status register. Mask prescaler bits. If status different from MR_SLA_NACK go to ERROR
  if ((TWSR & 0xF8) != MR_SLA_NACK)
  ERROR();
}

/*** Function to read one Databyte in Master Receive Mode and send NACK ***/
uint8_t TWI_READ_DATABYTE_NACK(void)
{
  // Clear TWINT bit in TWCR to start transmission with NACK
  TWCR = (1<<TWINT) | (1<<TWEN);
  // Wait for TWINT flag set. This indicates that the DATA has been received
  while (!(TWCR & (1<<TWINT)));
  // Check value of TWI status register. Mask prescaler bits. If status different from MR_SLA_NACK go to ERROR
  if ((TWSR & 0xF8) != MR_DATA_NACK)
  ERROR();
  return TWDR; // Return the value of data register
}

/*** Function to read one Databyte in Master Receive Mode and send ACK ***/
uint8_t TWI_READ_DATABYTE_ACK(void)
{
  // Clear TWINT bit in TWCR to start transmission with ACK
  TWCR = (1<<TWINT) | (1<<TWEA) | (1<<TWEN);
  // Wait for TWINT flag set. This indicates that the DATA has been received
  while (!(TWCR & (1<<TWINT)));
  // Check value of TWI status register. Mask prescaler bits. If status different from MR_SLA_ACK go to ERROR
  if ((TWSR & 0xF8) != MR_DATA_ACK)
  ERROR();
  return TWDR; // Return the value of data register
}

/*** function to send a STOP condition ***/
void TWI_STOP(void)
{
  TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWSTO); // Transmit STOP condition
}

/*** function to show a bus error ***/
void ERROR(void)
{
  PORTB |= (1<<PB1); // ERROR LED ON
}

uint8_t LSByte, MSByte;
uint16_t data_16bit, lux_value, high_byte, low_byte;

int main(void)
{
  //DDRD = 0xFF;            // PORTD = output
  //DDRC = 0x3F;            // PC0 ... PC5 = output
  DDRB = 0x03;            // PB0 and PB1 = output
  TWBR = BIT_RATE;        // Set the TWI clock-frequency in bit rate register
  //TWI_START();            // Send START condition
  //TWI_MT_SLA_ACK();       // Master Transmit Slave Address with Acknowledge
  //TWI_MT_DATA_ACK(0x00);  // Transmit 0x00 for Register Command with Acknowledge
  //TWI_STOP();             // Send STOP condition
  //_delay_ms(10);          // Delaytime between STOP and next START contition
  
  while(1)
  {
    TWI_START();            // Send START condition
    TWI_MT_SLA_ACK();       // Master Transmit Slave Address with ACK
    TWI_MT_DATA_ACK(0x00);  // Transmit 0x00 to start with Register 0x00 with ACK
    TWI_STOP();                         // Send STOP condition
    
    _delay_ms(200);                     // wait 200ms 
  }
}

[Da Huaba Bene (Gast)]

Michael H. schrieb:
> Vielleicht kann mir bitte jemand behilflich sein das ich zumindest mal
> etwas übertragen kann. Denn ich bin I2C Anfänger

Du müsstest schon deinen Schaltplan und deinen Aufbau zeigen.
Denn wir trauen einem "Anfänger" nur selten.
Eher trauen wir einem "Anfänger" alles zu, und das geht oft
schief.

Und deine Source wird so lang dass sie in einen Anhang gehört!

Das Beispiel das du hier

http://www.ne555.at/2014/index.php/bilder-zum-buch/520-lm75_tempsensor.html

kopiert hast ist auch sicherlich kein gutes Vorbild.
(nur als Beispiel: Grossbuchstaben verwendet man nur für
Konstanten, um sie von Variablen und Funktionen leicht
unterscheiden zu können)

Michael H. schrieb:
> * die nachfolgende Rechnung mit 62,5kHz wurde mit 8Mhz berechnet, das
> habe ich noch nicht verstanden wie dies funktioniert

Die Formel steht doch im Datenblatt, was ist daran nicht
zu verstehen? Es gibt zwei Variablen (Variationsmöglichkeiten),
die eine ist das TWBR (Baudraten-Register) und die andere ist
der Prescaler für den Prozessor Clock zum groben Voreinstellen.

Also, bis später.

[Michael H. (h_m)]

Danke schon ein mal für die Antwort.


Also der Schaltplan ist real genau so aufgebaut wie im Bild.
Jetzt bitte keine Diskussion :-) warum ich das mit der Schablone 
gezeichnet habe und nicht mit dem PC.

Da Huaba Bene schrieb:
> Das Beispiel das du hier
>
> http://www.ne555.at/2014/index.php/bilder-zum-buch/520-lm75_tempsensor.html
>
> kopiert hast ist auch sicherlich kein gutes Vorbild.
> (nur als Beispiel: Grossbuchstaben verwendet man nur für
> Konstanten, um sie von Variablen und Funktionen leicht
> unterscheiden zu können)

Das stimmt, nur ich habe das Originale Buch Davon. Und da ist alles sehr 
gut erklärt, wenn ich die Schaltung mit dem LM75 Aufbaue und mit 8Mhz 
betreibe funktioniert das ja einwandfrei und mit dem Lightsensor auch. 
Da sind die Schaltpläne alles im Buch dabei. Und ich kann es auch 
relativ gut nachvollziehen, Nur ich habe den Code von dem nächsten 
kopiert von dem Light_Sensor_ISL29020.c der unterscheidet sich das hier 
keine Pointeradresse verwendet wird.

Aber ich will ja nicht mehr nur den Lm75 Auslesen sondern ich will 
einmal mit dem in den Code verwendeten Funktionen Selbstständig eben den 
MCP4725 ansteuern. Bzw. einen Wert in das Register schreiben und ein 
Ergebnis am Vout sehen.


Um besseres Grundverständnis zu bekommen.

Datenblatt 4725
[[http://ww1.microchip.com/downloads/en/DeviceDoc/22039d.pdf]]



Da Huaba Bene schrieb:
> Michael H. schrieb:
>> * die nachfolgende Rechnung mit 62,5kHz wurde mit 8Mhz berechnet, das
>> habe ich noch nicht verstanden wie dies funktioniert
>
> Die Formel steht doch im Datenblatt, was ist daran nicht
> zu verstehen? Es gibt zwei Variablen (Variationsmöglichkeiten),
> die eine ist das TWBR (Baudraten-Register) und die andere ist
> der Prescaler für den Prozessor Clock zum groben Voreinstellen.
>
> Also, bis später.

Die Theorie verstehe ich natürlich dahinter, nur kann ich es Praktisch 
irgedwie in Bits makieren nicht umsetzen. Wenn die Berechnung jetzt erst 
einmal für die Funktion nicht so wichtig ist. Würde ich mich gerne auf 
das beschreiben des DAC konzentrieren, das ich mal etwas im Vout in 
Bewegung bekomme.

[Da Huaba Bene (Gast)]

Michael H. schrieb:
> Also der Schaltplan ist real genau so aufgebaut wie im Bild.

Dann hast du schon ein Problem.

In deiner Source initialisierst du Port B (vermutlich wegen
des TWI), aber dein Schaltplan zeigt die (korrekte) Anbindung
an PortC, Pin 4, 5.    Klingelt's?

Michael H. schrieb:
> Die Theorie verstehe ich natürlich dahinter, nur kann ich es Praktisch
> irgedwie in Bits makieren nicht umsetzen.

Den Wert den du ins Register schreibst entpricht hier einfach
dem Teilerwert der in der Formel steht.

Und beim TWSR gibt es zwei Bits die die vier Möglickeiten
Prescaler 1/2/16/64  repräsentieren.

[Da Huaba Bene (Gast)]

Da Huaba Bene schrieb:
> Dann hast du schon ein Problem.
>
> In deiner Source initialisierst du Port B (vermutlich wegen
> des TWI), aber dein Schaltplan zeigt die (korrekte) Anbindung
> an PortC, Pin 4, 5.    Klingelt's?

Bin mir nicht sicher ob das so sein muss.
Finde leider momentan den Abschnitt für die Pin Initialisierung
nicht im Datenblatt ...

[Da Huaba Bene (Gast)]

Da Huaba Bene schrieb:
> Bin mir nicht sicher ob das so sein muss.

In der Source die du als Vorbild genommen hast wird jedenfalls
Port C als Ausgang gesetzt.

[Michael H. (h_m)]

Da Huaba Bene schrieb:
> Michael H. schrieb:
>> Also der Schaltplan ist real genau so aufgebaut wie im Bild.
>
> Dann hast du schon ein Problem.
>
> In deiner Source initialisierst du Port B (vermutlich wegen
> des TWI), aber dein Schaltplan zeigt die (korrekte) Anbindung
> an PortC, Pin 4, 5.    Klingelt's?

Also Port B ist wegen des ERROR Lämpchen initialisiert, Das kann ich 
auch weglassen.

D.H. ich muss für SDA und SDL auch zumindest PC4 und 5 initialisieren ?

ich dachte das wäre geschehen als der I2c bus im Register eingestellt 
wurde. Denn mit dem Analogen Oszi habe ich zumindest Takte an SDA und 
SCL messen können.


Dann werde ich jetzt als erstes mal Port B ausklammern und PC4 und 5 als 
Ausgang setzen.

[Michael H. (h_m)]

Also Vout steht immer noch auf 2,5V. Und erwarten Tu ich das er mit 
meinem gesendeten nach 0V geht. Macht er aber nicht

das habe ich jetzt verändert bzw, gesendet

int main(void)
{
  //DDRD = 0xFF;            // PORTD = output
    DDRC = (1<<PC4) | (1<<PC5); // PC4 und PC5 = output
  //DDRB = 0x03;            // PB0 and PB1 = output
  TWBR = BIT_RATE;        // Set the TWI clock-frequency in bit rate register
  //TWI_START();            // Send START condition
  //TWI_MT_SLA_ACK();       // Master Transmit Slave Address with Acknowledge
  //TWI_MT_DATA_ACK(0x00);  // Transmit 0x00 for Register Command with Acknowledge
  //TWI_STOP();             // Send STOP condition
  //_delay_ms(10);          // Delaytime between STOP and next START contition
  
  while(1)
  {
    TWI_START();            // Send START condition
    TWI_MT_SLA_ACK();       // Master Transmit Slave Address with ACK
    TWI_MT_DATA_ACK(0x00);  // Transmit 0x00 to start with Register 0x00 with ACK
    TWI_STOP();                         // Send STOP condition
    
    _delay_ms(200);                     // wait 200ms 
  }
}

[Da Huaba Bene (Gast)]

Michael H. schrieb:
> Also Port B ist wegen des ERROR Lämpchen initialisiert, Das kann ich
> auch weglassen.

Muss man ja nicht - ist davon unabhängig ...

Michael H. schrieb:
> TWI_MT_DATA_ACK(0x00);
Du hast einen 12-Bit Wandler, der braucht auch 12 Bit als Datenwort.
Auch hier ist die Protokoll-Beschreibung im Datenblatt hilfreich.

[Michael H. (h_m)]

Ok das Stimmt, das ändert aber immer noch nichts an Vout.


ich habe jetzt Praktisch in der Funktion uint_8 data in uint_16 geädert

/*** Function to send 8Bit of data with ACK in Master Transmit Mode **/
void TWI_MT_DATA_ACK(uint16_t data)
{
  // Load DATA into TWDR register
  TWDR = data;
  // Clear TWINT bit in TWCR to start transmission
  TWCR = (1<<TWINT) | (1<<TWEN);
  // Wait for TWINT flag set. This indicates that the DATA has been transmitted, and ACK/NACK has been received.
  while (!(TWCR & (1<<TWINT)));
  // Check value of TWI status register. Mask prescaler bits. If status different from MT_DATA_ACK go to ERROR
  if ((TWSR & 0xF8) != MT_DATA_ACK)
  ERROR();
}

und in der While dann 4 NIBBLE

while(1)
  {
    TWI_START();            // Send START condition
    TWI_MT_SLA_ACK();       // Master Transmit Slave Address with ACK
    TWI_MT_DATA_ACK(0x0000);  // Transmit 0x00 to start with Register 0x00 with ACK
    TWI_STOP();                         // Send STOP condition
    
    _delay_ms(200);                     // wait 200ms 
  }

[Da Huaba Bene (Gast)]

Michael H. schrieb:
> Also der Schaltplan ist real genau so aufgebaut wie im Bild.

Finde den Unterschied!

Ist nicht kriegsentschedend, aber einen Meckerer auf jeden
Fall wert.

Denn die Aussage "also bei mir geht's auch ohne" haben wir
oft genug gehört.

[Da Huaba Bene (Gast)]

Michael H. schrieb:
> void TWI_MT_DATA_ACK(uint16_t data)

Auf dem I2C Bus kann man nur Bytes senden oder empfangen.

[Michael H. (h_m)]

Und das Bild von dem Datenblatt das habe ich mir Schon 10mal angeschaut, 
da träume ich heute noch davon,

Und genau das versuche ich in der Whileschleife umzusetzen, wenn es dann 
einmal funktioniert hat verstehe ich es auch.

[Da Huaba Bene (Gast)]

Da Huaba Bene schrieb:
> Auf dem I2C Bus kann man nur Bytes senden oder empfangen.

und deine Funktion

Michael H. schrieb:
> /*** Function to send 8Bit of data with ACK in Master Transmit Mode **/
> void TWI_MT_DATA_ACK(uint16_t data)

kann nur 8 Bit senden (es steht sogar im Kommentar, und die
AVR Register sind auch nur 8 Bit breit), auch wenn du ihr 173
Bits übergibst.

[Florian P. (ol1cr0n)]

Ganz klarer Fall von Datenblatt nicht gelesen. Schaue dir Figure 6-1 
nochmal an. Das ist das was du übertragen musst. Laut deiner 
Beschreibung sendet dein Master ein ACK. Soll das so?

Wie wäre es wenn du Byte für Byte so sendest wies im Datenblatt steht?


Start();
SendAdr();
Wait4ACK();
SendHighByte();
Wait4ACK();
SendLowByte();
Wait4ACK();
Stop();

[Michael H. (h_m)]

Also die Kondensatoren habe ich nachgerüstet. keine Änderung.

Da Huaba Bene schrieb:
> Da Huaba Bene schrieb:
>> Auf dem I2C Bus kann man nur Bytes senden oder empfangen.
>
> und deine Funktion
>
> Michael H. schrieb:
>> /*** Function to send 8Bit of data with ACK in Master Transmit Mode **/
>> void TWI_MT_DATA_ACK(uint16_t data)
>
> kann nur 8 Bit senden (es steht sogar im Kommentar, und die
> AVR Register sind auch nur 8 Bit breit), auch wenn du ihr 173
> Bits übergibst.


Das hatte ich schon irgendwie im Hinterkopf, das ist das was ich eben 
jetzt noch nicht so ganz verstehe.

Müsste ich im dann die 2 Bytes nach einander senden? das ist ja das was 
in dem Bild beschrieben ist ? die 4bits für den Fast Modus etc und 4bit 
für den Wert, und das nächste Byte mit 8bit noch einmal für den Wert.


Aber wie Sende ich das jetzt zweimal nacheinander ?

  while(1)
  {
    TWI_START();            // Send START condition
    TWI_MT_SLA_ACK();       // Master Transmit Slave Address with ACK
    TWI_MT_DATA_ACK(0x00);  // Transmit 0x00 to start with Register 0x00 with ACK
    TWI_R_START();
    TWI_MT_DATA_ACK(0x00);  // Transmit 0x00 to start with Register 0x00 with ACK
    TWI_STOP();                         // Send STOP condition
    
    _delay_ms(200);                     // wait 200ms 
  }

So dann habe ich auch noch gleich die Funktion wieder in den Original 
Zustand gebracht

/*** Function to send 8Bit of data with ACK in Master Transmit Mode **/
void TWI_MT_DATA_ACK(uint8_t data)
{
  // Load DATA into TWDR register
  TWDR = data;
  // Clear TWINT bit in TWCR to start transmission
  TWCR = (1<<TWINT) | (1<<TWEN);
  // Wait for TWINT flag set. This indicates that the DATA has been transmitted, and ACK/NACK has been received.
  while (!(TWCR & (1<<TWINT)));
  // Check value of TWI status register. Mask prescaler bits. If status different from MT_DATA_ACK go to ERROR
  if ((TWSR & 0xF8) != MT_DATA_ACK)
  ERROR();
}

Allerdings hat sich noch nichts geändert. An Vout

[Michael H. (h_m)]

DANKE, DANKE ES KLAPPT !!!

Zwei Byte direkt nacheinander Senden (hinschreiben) und Gut ist, ich 
dachte da muss man dazwischen die Konversation neu starten

[Da Huaba Bene (Gast)]

Michael H. schrieb:
> TWI_R_START();

Wo ist im Datenblatt an bereits gezeigter Stelle ein
Repeated Start zu finden?

Michael H. schrieb:
> Aber wie Sende ich das jetzt zweimal nacheinander ?

Entweder Troll und unfähig.

Ich bin dann mal weg.

[Kopf Schüttel (Gast)]

Michael H. schrieb:
> ich habe jetzt Praktisch in der Funktion uint_8 data in uint_16 geädert
>
> /*** Function to send 8Bit of data with ACK in Master Transmit Mode **/
> void TWI_MT_DATA_ACK(uint16_t data)
> {
>   // Load DATA into TWDR register
>   TWDR = data;
>   // Clear TWINT bit in TWCR to start transmission
>   TWCR = (1<<TWINT) | (1<<TWEN);
>   // Wait for TWINT flag set. This indicates that the DATA has been
> transmitted, and ACK/NACK has been received.
>   while (!(TWCR & (1<<TWINT)));
>   // Check value of TWI status register. Mask prescaler bits. If status
> different from MT_DATA_ACK go to ERROR
>   if ((TWSR & 0xF8) != MT_DATA_ACK)
>   ERROR();
> }

Ich frage mich schon was man im Kopf haben muss um anzunehmen
dass die Änderung eines Datentyps von 8 auf 16 Bit im Übergabe-
Parameter das innere der Funktion gleich so ändert wie man es
gerne haben möchte.

Manchmal kann man einfach nicht glauben was da alles daherkommt.

[Michael H. (h_m)]

Jetzt habe ich noch eine Frage, und zwar gibt es die Möglichkeit die 
12bit die ja nacheinander gesendet werden. Auch in eine Variable zu 
packen damit man praktisch in dezimal von 0-4095 senden kann ?

und jetzt nicht gleich wieder unfähig etc. ich hab gesagt das ich das 
erst am anfang mache, ich habe mich auch bei huaba bedankt und war Froh 
das er sich die Zeit überhaupt genommen hat

[Da Huaba Bene (Gast)]

Michael H. schrieb:
> und zwar gibt es die Möglichkeit

Das klingt nach Alternative, aber es gibt keine.

Der 16-Bit Wert, von dem 12 genutzt werden ist in zwei Bytes
aufzuteilen (oberes Byte mit den Steuerbits verknüpft) und
nacheinander zu senden.

Das Bild vom Protokoll stellt doch ganz klar dar wie es zu
machen ist. Oder habe ich ein "alternatives" Protokoll
übersehen?

[Michael H. (h_m)]

Nö Nö das ist alles richtig.


wenn ich es zb. so sende stellet er sich auf null ein, alles gut.

while(1)
  {
    TWI_START();            // Send START condition
    TWI_MT_SLA_ACK();       // Master Transmit Slave Address with ACK
    TWI_MT_DATA_ACK(0x00);  // Transmit 0x00 to start with Register 0x00 with ACK
    //TWI_R_START();
    TWI_MT_DATA_ACK(0x00);  // Transmit 0x00 to start with Register 0x00 with ACK
    TWI_STOP();                         // Send STOP condition
    
    _delay_ms(200);                     // wait 200ms 
  }

aber was mache ich jetzt wenn ich zb.

 Zaehlwert = 4095 ;

also die Variable übergebn will bzw. ins Register schreiben will, das 
müsste man ja dann auch aufteilen

[Da Huaba Bene (Gast)]

Michael H. schrieb:
> das müsste man ja dann auch aufteilen

Du hast es erfasst!

Was heisst da "auch", ja man muss es aufteilen. Das ist
immer so, wenn ein Wert nicht in ein Byte hineinpasst.

Oh man ....

[Michael H. (h_m)]

Das 4095 nicht in ein Byte passt ist mir auch Klar,

mal angenommen ich lese ein Poti über den Adc ein, und mache einen Wert 
von 0-4095 in ein Variable, wie würde man das dann mit I2C übergeben. 
Oder ist das dann gar nicht möglich, und man kann das nur binär 
übergeben ?

[Einer K. (Gast)]

Michael H. schrieb:
> wie würde man das dann mit I2C übergeben.
> Oder ist das dann gar nicht möglich, und man kann das nur binär
> übergeben ?
EDV funktioniert grundsätzlich binär...
(in 99,9999% aller Fälle)

Du musst dein Datenwort in Byte aufteilen und diese Bytes dann senden.


Wurde aber schon gesagt:
Da Huaba Bene schrieb:
> Der 16-Bit Wert, von dem 12 genutzt werden ist in zwei Bytes
> aufzuteilen (oberes Byte mit den Steuerbits verknüpft) und
> nacheinander zu senden.

[Sherlock Holmes (Gast)]

Arduino Fanboy D. schrieb:
> Wurde aber schon gesagt:

Ab jetzt gilt wirklich höchster Troll-Verdacht!

Aber warum die Leute sowas machen ist mir schleierhaft .....

[Michael H. (h_m)]

Arduino Fanboy D. schrieb:
> Du musst dein Datenwort in Byte aufteilen und diese Bytes dann senden.
>
> Wurde aber schon gesagt:
> Da Huaba Bene schrieb:
>> Der 16-Bit Wert, von dem 12 genutzt werden ist in zwei Bytes
>> aufzuteilen (oberes Byte mit den Steuerbits verknüpft) und
>> nacheinander zu senden.

Das weiß ich ja, das hat er mir im Datenblatt schon gezeigt, und so 
funktioniert es ja auch.

es gibt aber auch eine Dezimale Schreibweise ,und das will ich wissen ob 
das dann hier überhaupt möglich ist?

[Einer K. (Gast)]

Michael H. schrieb:
> es gibt aber auch eine Dezimale Schreibweise
Die ist nur für Menschen.

Unterscheide zwischen Daten und Präsentation.

[Sherlock Holmes (Gast)]

Michael H. schrieb:
> es gibt aber auch eine Dezimale Schreibweise

Ohhh man, ob du dem I2C Bus zweimal 0 und 0 sendest oder
zweimal 0x00 und 0x00 ist vollkommen egal, das ist eine
unterschiedliche Schreibweise sonst nichts.

[Sherlock Holmes (Gast)]

Michael H. schrieb:
> es gibt aber auch eine Dezimale Schreibweise

Was hast du eigentlich in den zwei Jahren in denen du hier
online bist (äääähj dein Unwesen treibst) gelernt ausser
Copy&Paste Operationen auszuführen?

[Michael H. (h_m)]

ÄHH.. was soll den sowas jetzt, sie haben sich natürlich hingesetzt und 
sofort alles verstanden und ihre Fragen die aufkamen, perfekt 
zielführend formulieren können.Danke, Glück gehabt.


dann versuche ich es jetzt noch einmal ich weise einer Variablen zb.

Wert = 4000 zu, das passt jetzt natürlich nicht in ein Byte, wenn ich 
das jetzt mit dem I2c an den Wandler senden will

TWI_MT_DATA_ACK(Wert); dann stimmt das ja nicht, das meine ich wie ich 
das hier umsetzen kann ?

[Sherlock Holmes (Gast)]

Du teilst <Wert > in zwei Bytes auf und sendest die Bytes
hintereinander. So einfach ist das.

[Bastian W. (jackfrost)]

Michael H. schrieb:
> ÄHH.. was soll den sowas jetzt, sie haben sich natürlich hingesetzt und
> sofort alles verstanden und ihre Fragen die aufkamen, perfekt
> zielführend formulieren können.Danke, Glück gehabt.
>
>
> dann versuche ich es jetzt noch einmal ich weise einer Variablen zb.
>
> Wert = 4000 zu, das passt jetzt natürlich nicht in ein Byte, wenn ich
> das jetzt mit dem I2c an den Wandler senden will
>
> TWI_MT_DATA_ACK(Wert); dann stimmt das ja nicht, das meine ich wie ich
> das hier umsetzen kann ?

Das obere Byte kannst mit (Wert >> 8) senden. Für das untere machst Dir 
einfach bitweises und mit 0xff (Wert & 0xff).

Beides am besten noch mit (uint8_t) casten.

Gruß JackFrost