Teile einer HEX/DEZ auswerten

[mr_sol]

Wenn das 11 Byte sind, kannst du die doch nicht in einen long/int packen (4 Byte).

Von diesen 11 Byte werden nur maximal 4 Bytes verwendet. zB Byte 5-8 sind die Sensorwerte. In diesen sind wiederum verschiedene Daten eingebettet welche vom Hersteller zb ab 2 Bit auf Länge von 4 Bit den Temperaturbereich.

Etwas verkorkst aber die geizen mit jedem Bit


Beispieltelegramm wie vorher

0xA5,0x5A,0x0B,0x07,[0x00,0x00,0x41,0x09],0x00,0x80 ,0x36,0x11,0x00,0x23

wäre dann 5te Byte Länge 4
0x00,0x00,0x41,0x09

und von diesen ab den 2es Bit Länge 4 der gesuchte Wert

Die Anzahl der auszulesenden Bytes liegt zwischen 1 maximal 4Byte daher -> Long


Wo könnte der Fehler liegen?

[Christian Marquardt]

Versuche das mit debuggen festzustellen

[mr_sol]

Hallo Christian

Komm nicht drauf, habe die Funktion weiter verbessert.Debugging ist schierig, da es sich nicht um eine "normale" IDE handelt, sonder eine für MCs.

ByteSize:

Bei Testarray {0xA5,0x5A,0x0B,0x07,0x00,0x00,0x41,0x09,0x00,0x80 ,0x36,0x11,0x00,0x23}

und den Funktionaufruf

ByteToLong(Test,7,0,32) - Ab den 7 Byte 32 Bit lang den Wert abholen

bekomme ich:
bp[7]<<24-9-1001-1001-
bp[8]<<16-0-0-10010000000000000000-
bp[9]<<8-80-10000000-1001000000000000000010000000-
bp[10]<<0-36-110110-1001000000000000000010110110-
90000B6 (Das Ergebnislong wieder geHEXd - zu Testzwecken)

statt 09008036 ??????

/** 
* Auslesen Daten aus einen Telegramm
* 
* Aus einen Datentelegramm welches serial verarbeitet wird, 
* werden Bytebloecke mit Informationen versehen (Startbyte: ByteOffset)
* in diesem befinden sich widerum verteilte Information (Startbit:BitOffset ,Laenge:BitSize)
* Diese Teileinformation wird als Long retourniert
*
* @V0.1      2011.07.30 
*/
unsigned long ByteToLong( byte const *bp, byte ByteOffset, byte BitOffset, byte BitSize)
{
  
  //**** Anzahl der zu verfuegungstehenden Byte festlegen
  float c=(((double)BitOffset+(double)BitSize)/8);


  //**** Aus der Anzahl der Bits, Bytes bestimmen (zb 9 Bit -> 2 Bytes)
  byte ByteSize=0;
  if ((c) - (int)(c) > 0) {
    ByteSize=(int)(c) + 1;
  }
  else {
    ByteSize=(int)c;
  }

  Serial.println("ByteSize:");  
  Serial.println(ByteSize,DEC);
  Serial.println("---");


  unsigned long value=0;
  byte  b[]={0,8,16,24};
  

  //**** Anzahl der Byte liegt von 1 bis maximal 4
  for(byte a=0;a<ByteSize;a++)
  {  
  Serial.print("bp[");
  Serial.print(ByteOffset+a,DEC);
  Serial.print("]<<");
  Serial.print((ByteSize-a-1)*8,DEC);
  Serial.print("-");
  Serial.print(bp[ByteOffset+a],HEX);
  Serial.print("-");
  Serial.print(bp[ByteOffset+a],BIN);
  Serial.print("-");
  
  value <<= (ByteSize-a-1)*8;
  value |= (long)bp[ByteOffset+a]; 
  
  Serial.print(value,BIN);
  Serial.println("-");
  }
  

  value<<=ByteSize*8-(BitOffset+BitSize);
  value>>=ByteSize*8-BitSize;

 
return(value);

}

was sagt du - eine idee?

[Fred Nest]

Salve!

Warum alles so kompliziert. Grundlagen lernen!

typedef struct{
BYTE l1;
BYTE l2;
BYTE l3;
BYTE l4;
}MyLONG;

MyLONG m;
m.l1 = dein byte 1; // oder 0
m.l2 = dein byte 2; // oder 0
m.l3 = dein byte 3; // oder 0
m.l4 = dein byte 4; // oder 0

( l1 + l2 + l3 + l4 = 0-255 256-65535 65536-16777215 16777216-max je nachdem ob
signed oder unsigned )

long x = 0;

memcpy( &x, &m, 4 );

Ergebnis ist da, und läßt sich auch wunderbar debuggen
wenn man was sucht.

gruß fred

[mr_sol]

Hallo Fred!

Danke für deine Lösung.