16Bit Wert aus 8Bit Array

[Rene K. (xdraconix)]

Frage: da ja ein Feld in einem Array bloß auf eine Speicheradresse 
zeigt. Kann man den beim Auslesen mit einem 2 Byte großen Wert 
"weiterlesen"? Also wie folgt:

uint16_t u_value    = 0x1337;
uint8_t  c_array[5] = {0x13,0x37,0x15,0x16,0x17}; 


if(c_array[0] == u_value)
{
    //true
}
else
{ 
    //false
}

Was passiert in diesem Fall bei einer Zuweisung?

uint16_t u_value    = 0x1337;
uint8_t  c_array[5] = {0x00,0x00,0x00,0x00,0x00}; 

c_array[0] = u_value;

[Nop (Gast)]

Rene K. schrieb:

> Frage: da ja ein Feld in einem Array bloß auf eine Speicheradresse
> zeigt. Kann man den beim Auslesen mit einem 2 Byte großen Wert
> "weiterlesen"?

Nein, nicht ohne Weiteres.

> if(c_array[0] == u_value)

Wird immer "false" sein.

> Was passiert in diesem Fall bei einer Zuweisung?

u_value wird nach uint8_t gecastet, unter Bitverlust, und dann 
zugewiesen. Also die untersten 8 Bits, wenn ich das richtig sehe.

Man kann da auch nichts mit Pointercasting reißen, weil das Aliasing 
wäre und nach C-Standard nicht definiert. Allenfalls mit ner Union wäre 
da was zu machen.

[Dennis H. (c-logic)]

if((uint16_t)(c_array[0] | c_array[0+1]<<8 ) == u_value) {

....

[Rene K. (xdraconix)]

Alles klar, danke :-D Naja, bevor da ich da mit Unions "rumspiele" 
(Wobei da auch das Problem der Zuweisung ja weiterhin besteht) - 
Bitschubse (TM) ich mir dann halt einfach [0]..[1] in eine uint16 
zusammen und vergleiche das so oder Bitreiße (TM) es dann wieder zu 
einzelnen Bytes auseinander. :-)

Danke für deine Aufklärung.



EDIT:

Dennis H. schrieb:
> if((uint16_t)(c_array[0] | c_array[0+1]<<8 ) == u_value) {
>
> ....

Ja genau so :-D

[Nop (Gast)]

Das geht auch, allerdings solltest Du Dir dann Gedanken über korrekte 
Endianess machen.

[Nop (Gast)]

Nop schrieb:

> korrekte Endianess

Wobei das bei der Union natürlich auch nicht anders wäre.

[Rene K. (xdraconix)]

Nop schrieb:
> Das geht auch, allerdings solltest Du Dir dann Gedanken über korrekte
> Endianess machen.

Das Projekt ist nur für eine Architektur gedacht. Kann ich 
vernachlässigen. Aber danke für den Hinweis.

EDIT:

Nen Union (wo das ich eigentlich nicht nutzen will) dafür sähe dann so 
aus oder:

typedef union
{
     uint8_t c_array[5];

     uint16_t u_First16 : 2;
     uint16_t u_Secon16 : 2;
     uint8_t  u_Lastone : 1;
} un_value;


// Kann ich das Union auch "offen" lassen? Oder gibt das Speicherprobleme?

typedef union
{
     uint8_t c_array[5];
     uint16_t u_First16 : 2;

} un_value;

[Nop (Gast)]

ich würd die zweite Komponente der Union mit nem struct aus zwei uint16 
und einem uint8 machen.

[Nop (Gast)]

Etwa so:

struct uintwise {
  uint16_t uint_0;
  uint16_t uint_1;
  uint8_t trailbyte;
};

typedef union {
  struct uintwise uints;
  uint8_t c_array[5];
} T_ENTRY_5_BYTES;

[Dirk B. (dirkb2)]

Es gibt immer noch memcpy aus der Standard Library.

[A. S. (Gast)]

im Embedded-Bereich sollte man sich für den direktn Zugriff mit anderer 
Bitbreite entsprechende Routinen bereithalten. Verschiedene Arten sind 
möglich, ich gebe mal Beispiele für den 16-Bit-Zugriff (Word). 
Entscheide Dich  für eine Art, die in Deinem Projekt am sinnvollsten ist 
und implementiere sie dann für alle benötigten Breiten als Inline oder 
als #define

/* direkter Zugriff auf angegebene Adresse */
uint16 word_access1(void *p) 
{
    return *((uint16 *)p);
}
/* mit offs = 0: Byte 0,1; offs=1: Byte 2,3 */
uint16 word_access2(void *p, int offs)
{
    return *(((uint16 *)p)+offs);
}
/* angabe der Variable im Makro, nicht die Adresse! */
#define word_access3(a) (*(((uint16 *)&(a)))

/* in Deinem Beispiel */
uint16_t u_value    = 0x1337;
uint8_t  c_array[5] = {0x13,0x37,0x15,0x16,0x17}; 

if(u_value == word_access1(c_array))     ..
if(u_value == word_access1(&c_array[0])) ..
if(u_value == word_access2(c_array, 0)   ..
if(u_value == word_access3(c_array[0])   ..

Mit dem Makro kannst Du an der Adresse mit 16 Bit lesen und schreiben!

word_access3(c_array[0]) = 0xdead; /* ueberschreibt c_array[0] und [1] */

Wenn Du es nicht willst, caste auf (const uint16 *).

[Peter II (Gast)]

Rene K. schrieb:
> Dennis H. schrieb:
>> if((uint16_t)(c_array[0] | c_array[0+1]<<8 ) == u_value) {
>>
>> ....
>
> Ja genau so :-D

wobei der cast nicht notwenig ist. es wird immer mit 16bit gerechnet.

if((c_array[0] | c_array[0+1]<<8 ) == u_value) {

[Waldo (Gast)]

union {
uint_8 i8[2];
uint_16 i16;
} buffer;

buffer.i8[0] = c_array[0];
buffer.i8[1] = c_array[1];

if(buffer.i16 == u_value)
{
    //true
}
else
{
    //false
}