-         

Ergebnis 1 bis 7 von 7

Thema: I2C - 16Bit übertragen

  1. #1
    Benutzer Stammmitglied
    Registriert seit
    26.10.2008
    Ort
    Wien
    Alter
    37
    Beiträge
    38

    I2C - 16Bit übertragen

    Anzeige

    Hallo I2C Profis,

    schön langsam komme ich mit dem I2C klar und ich kann vom Slave zum Master und umgekehrt Werte hin und her verschieben wie ich will. Allerdings leider nur Werte bis 255! Eigentlich eh klar, da ja das Leseregister mit 8Bit deklariert ist, sehe ich das richtig?

    Wie sieht es aber dann aus, wenn ich 16Bit Variablen in das Leseregister schreiben will?

    Zur Veranschaulichung hier ein kleines Beispiel -> siehe mein Kommentar!

    Danke...

    Code:
    #include "RP6RobotBaseLib.h"
    #include "RP6I2CslaveTWI.h"
    
    // **********************************************************************************************************
    // **********************************************************************************************************
    // ******************************************                 ***********************************************
    // ******************************************  Hauptprogramm  ***********************************************
    // ******************************************                 ***********************************************
    // **********************************************************************************************************
    // **********************************************************************************************************
    
    int main(void)
    {
      initRobotBase();
      I2CTWI_initSlave(10);
      powerON();
      
      task_ADC();
      
      while(true)
      {
    	if(!I2CTWI_readBusy)
          I2CTWI_readRegisters[0] = 255;		// Alles funktioniert so lange der Wert <=255 ist - leider ;-)
    	  
    	if (bumper_left) 						// wird der Bumper gedrückt wird der Wert im Terminal ausgegeben
    	{
    	  writeString("\n");
    	  writeString("Wert: ");writeIntegerLength(I2CTWI_readRegisters[0], DEC, 5);writeString("\n");
    	}
    	task_Bumpers();
      }
    
    return 0;
    }

  2. #2
    Erfahrener Benutzer Robotik Einstein Avatar von 021aet04
    Registriert seit
    17.01.2005
    Ort
    Niklasdorf
    Alter
    29
    Beiträge
    4.544
    Du musst die Daten dann in mehrere 8bit Teile splitten.

  3. #3
    Benutzer Stammmitglied
    Registriert seit
    26.10.2008
    Ort
    Wien
    Alter
    37
    Beiträge
    38
    Hab ich schon gemacht - dachte nur, es gäbe eine einfachere Lösung

  4. #4
    Erfahrener Benutzer Roboter Genie Avatar von SlyD
    Registriert seit
    27.11.2003
    Ort
    Paderborn
    Alter
    32
    Beiträge
    1.514
    Schau Dir das I2C Protokoll an - da werden nunmal (wie auch bei UART und SPI und ... ) immer Bytes übertragen.

    Einfach eine passende Funktion schreiben!
    Schau Dir z.B. die Funktion "move" im RP6Control_10_move2 / RP6Control_I2CMasterLib.c an. Dort werden 16 Bit Werte übertragen.
    Die umgekehrte Richtung findest Du im I2C Slave programm Zeile 365.


    Das lässt sich natürlich auch auf 32 Bit erweitern.

    MfG,
    SlyD

  5. #5
    Benutzer Stammmitglied
    Registriert seit
    26.10.2008
    Ort
    Wien
    Alter
    37
    Beiträge
    38
    Habe es immo so gelöst, dass ein Wert (z.B. 599) im Slave durch 255 dividiert wird und dann der Quotient sowie der Rest (in dem Fall 89) an den Master übergeben wird. Dort dann wieder zurück gerechnet komme ich wieder auf die 599.

    Etwas kompliziert und deshalb gut zu wissen, dass es auch mit 16bit oder 32bit usw. geht...

    Werde das morgen durch ackern... Für heute raucht mein Kopf schon genug... und die Akkus vom RP6 sind auch leer

  6. #6
    Moderator Robotik Visionär Avatar von radbruch
    Registriert seit
    27.12.2006
    Ort
    Stuttgart
    Alter
    54
    Beiträge
    5.781
    Blog-Einträge
    8
    Hallo

    Du solltest besser durch 256 dividieren.

    Ein 2-Byte-Wert ist 256*highbyte+lowbyte. Bit0 des Highbytes ist auch Bit8 der 16bit-Variablen und hat die Wertigkeit 2^8=256.
    Mit 255 funktioniert es nur bei Werten die kleiner als 256*255-1 sind, in eine 16Bit-Variable passen aber 256*256-1=65535 Werte.

    Klassisch macht man das wohl so wie bei der Baudratenberechnung:

    highbyte = 16bit-Variable >> 8;
    lowbyte = (uint8_t) 16bit-Variable;


    Und zurückrechnen geht so:

    16bit-Variable=256*highbyte+lowbyte;

    Gruß

    mic

    Atmel’s products are not intended, authorized, or warranted for use
    as components in applications intended to support or sustain life!

  7. #7
    Benutzer Stammmitglied
    Registriert seit
    26.10.2008
    Ort
    Wien
    Alter
    37
    Beiträge
    38
    Zitat Zitat von radbruch
    Du solltest besser durch 256 dividieren.
    Bei meiner Division habe ich eh schon 256 verwendet!

    Aber trotzdem Danke für deinen Lösungsansatz mit der Bit-Verschiebung... Ist zwar auf den ersten Blick die verwirrendere Lösung, aber wenn man's einmal kapiert hat wie die Verschiebung um 8Bit funzt (hab die letzte halbe Stunde mit Nullen und Einsern herumjoungliert) eindeutig die elegantere. Werde ich zu Hause gleich mal umschreiben...

    THX

    Aircode

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •