Wie lauten diese Codezeilen (Keil-Compiler) für GCC?

[Lars (Gast)]

Ich versuche mich gerade an der Ansteuerung eines Displays per 4-Wire 
SPI Mode bzw. an dem Samplecode des Herstellers, kann aber mit zwei 
Zeilen nach dem #define (wohl Keil-Compiler) nichts anfangen. Wie 
schreibt man das für den GCC-Compiler um? Wäre lieb, wenn mir das jemand 
kurz erklären würde.

uchar bdata transdata;      
sbit transbit = transdata^7;

Hier nochmal im Kontext mit der Funktion

#define uchar unsigned char


uchar bdata transdata;      
sbit transbit = transdata^7;




void SdCmd(uchar cmd)
{
  uchar j;
  transdata = cmd;            // The command put in BIT-byte variable 
  SCK  = 1;          // Initial SCK
  D_C  = 0;          // D_C = 0£¬select command register 
  _CS  = 0;          // Enable the access       

  SCK  = 0;
  for(j=0;j<8;j++)
  {
  SDA  = transbit;        // To Start transfer From Highest bit 
  SCK  = 1;          // Enable at rising SCK edge
  SCK  = 0;          // Prepare write signal for next bit
  transdata = transdata<<1;      // One bit left shift 
  }
  _CS  = 1;          // Disable the access  
}

[DraconiX (Gast)]

Bitte sehr:

http://bfy.tw/COSl

[Bit By Bit (Gast)]

Lars schrieb:
> uchar bdata transdata;
> sbit transbit = transdata^7;

anstatt umschreiben zu lassen, wäre verstehen wichtiger:
uchar bdata => 8-Bit Variable, die im Bit-adressierbaren Bereich, z. 
B. beim c167, plaziert wird.

sbit transbit = transdata^7 => Bit-Variable (bool), die jetzt das 
höchstwertige Bit (7) von transdata repräseniert.

Das wird auch oft bei Bit-adressierbaren Registern benutzt. Wirf mal nen 
Blick in den Header zum µC.

[Schmierlappen (Gast)]

DraconiX schrieb:
> Bitte sehr:
>
> http://bfy.tw/COSl

Was für ein Schmierlappen bist Du doch!

[Nop (Gast)]

Lars schrieb:

> #define uchar unsigned char

Typen mit define zu definieren, sollte man generell lassen. Dafür gibt's 
typedef.

Außerdem hat man normalerweise für den Anwendungsfall hier sowieso schon 
den Datentyp uint8_t.

[Rene K. (xdraconix)]

Schmierlappen schrieb:
> DraconiX schrieb:
> Bitte sehr:
> http://bfy.tw/COSl
>
> Was für ein Schmierlappen bist Du doch!

Warum?! Es ist absolute Grundlage! Die unsigned char sollte völlig 
selbstklärend sein. Das sbit ist eben ein Bit (Bit 7 in dem Fall) in 
eben diesem uchar.

Und richtig:

Nop schrieb:
> Typen mit define zu definieren, sollte man generell lassen. Dafür gibt's
> typedef.

Das gehört sich einfach nicht. Oder man sollte verstehen lernen was das 
define darüber überhaupt macht.

[W.S. (Gast)]

Nop schrieb:
> Typen mit define zu definieren, sollte man generell lassen. Dafür gibt's
> typedef.

Ach wo. Eigentlich ist das egal, ob die Ersetzung beim Präprozessor oder 
etwas weiter hinten erfolgt.

Dieses Wort "typedef" suggeriert einem, daß man damit Typen definieren 
könnte, aber das ist FALSCH. Mit typedef kann man lediglich einem 
bereits vorhandenen Typ einen zweiten Namen geben.

Ob man sowas wirklich gut findet, ist Geschmackssache. Ich halte typedef 
für herzlich überflüssig. Da wären zuvor ganz andere Dinge in C 
verbesserungswürdig.

W.S.

[N. G. (newgeneration)]

W.S. schrieb:
> Nop schrieb:
>> Typen mit define zu definieren, sollte man generell lassen. Dafür gibt's
>> typedef.
>
> Ach wo. Eigentlich ist das egal, ob die Ersetzung beim Präprozessor oder
> etwas weiter hinten erfolgt.
>
> Dieses Wort "typedef" suggeriert einem, daß man damit Typen definieren
> könnte, aber das ist FALSCH. Mit typedef kann man lediglich einem
> bereits vorhandenen Typ einen zweiten Namen geben.
>
> Ob man sowas wirklich gut findet, ist Geschmackssache. Ich halte typedef
> für herzlich überflüssig. Da wären zuvor ganz andere Dinge in C
> verbesserungswürdig.
>
> W.S.

Falsch:

#define defined_type_t unsigned char*
typedef unsigned char *typdef_type_t;

int main(void) {
  unsigned char c;
  
  typdef_type_t  t_a, t_b;
  defined_type_t d_a, d_b;
  
  t_a = &c; /* kein problem */
  t_b = &c; /* kein problem */
  d_a = &c; /* kein problem */
  d_b = &c; /* Fehler! */
  
  return 0;
}

liefert natürlich

13:8: error: assigning to 'unsigned char' from incompatible type 'unsigned char *'; remove &
        d_b = &c; /* Fehler! */
              ^~

Wenn du jetzt sagst, dass man so etwas nicht macht: doch, es gibt Leute, 
die das genau so schreiben.
Natürlich gibt es auch häufig typedefs auf Pointer, wenn man zum 
Beispiel den Inhalt einer Struct verbergen will.
Typedef macht also sehrwohl Sinn.

Mit freundlichen Grüßen,
N.G.

[Carl D. (jcw2)]

N. G. schrieb:
> W.S. schrieb:
>> Ob man sowas wirklich gut findet, ist Geschmackssache. Ich halte typedef
>> für herzlich überflüssig. Da wären zuvor ganz andere Dinge in C
>> verbesserungswürdig.
>>
>> W.S.
.
> Falsch:
> #define defined_type_t unsigned char*
>   unsigned char c;
>
>   defined_type_t d_a, d_b;
>
>   d_b = &c; /* Fehler! */
>
> liefert natürlich
> 13:8: error: assigning to 'unsigned char' from incompatible type
> 'unsigned char *'; remove &
>         d_b = &c; /* Fehler! */
>               ^~
> Wenn du jetzt sagst, dass man so etwas nicht macht: doch, es gibt Leute,
> die das genau so schreiben.

Ja, so ist das eben wenn man den Unterschied "Typ" und "Textersatz" 
100%tig verstanden hat


;-)

[Frank M. (ukw) (Moderator)]

Lars schrieb:
> uchar bdata transdata;

Da fehlt ein Komma. Richtig wäre hier:

uchar bdata, transdata;

bleibt noch die Zeile für den Typ sbit. Dazu gab es ja schon 
hinreichende Hinweise.

[Carl D. (jcw2)]

Frank M. schrieb:
> Lars schrieb:
>> uchar bdata transdata;
>
> Da fehlt ein Komma. Richtig wäre hier:
>

> uchar bdata, transdata;
>

>
> bleibt noch die Zeile für den Typ sbit. Dazu gab es ja schon
> hinreichende Hinweise.

Lars schrieb:
> uchar bdata transdata;
> sbit transbit = transdata^7;
Alles x51-spezifisch.
  bdata: bitaddressierbares RAM
  sbit:  Bit 7 in der bdata-Variable (Standard-c hat da das Bitfield)

  struct transdate_t {
    uint8t transbit:1;
  };

  transdata_t transdata;


  transdata.transbit = 1;

  if(transdata.transbit) {
    // ...
  }

[Bit By Bit (Gast)]

Frank M. schrieb:
> Da fehlt ein Komma.

Nö,

Bit By Bit schrieb:
> uchar bdata => 8-Bit Variable, die im Bit-adressierbaren Bereich, z.
> B. beim c167, plaziert wird.

[Bit By Bit (Gast)]

Carl D. schrieb:
> sbit:  Bit 7 in der bdata-Variable (Standard-c hat da das Bitfield)
> struct transdate_t {
>     uint8t transbit:1;
>   };

Welches Bit vom uint8_t wird hier angesprochen???

Die Anordnung der Bitfelder ist dem Compiler überlassen. Beim sbit 
übernimmst du das. ;-)

[Carl D. (jcw2)]

Bit By Bit schrieb:
> Carl D. schrieb:
>> sbit:  Bit 7 in der bdata-Variable (Standard-c hat da das Bitfield)
>> struct transdate_t {
>>     uint8t transbit:1;
>>   };
>
> Welches Bit vom uint8_t wird hier angesprochen???
>
> Die Anordnung der Bitfelder ist dem Compiler überlassen. Beim sbit
> übernimmst du das. ;-)

Das interessiert doch bei reinen Software-Flags Überhaupt nicht.
Wenn ich die bitaddressierbarene x51-Special-Function-Register 
definieren muß, dann ist das was anderes. Da ist die Bit-Position ins 
Silizium gebrannt.

[Bit By Bit (Gast)]

Carl D. schrieb:
> Das interessiert doch bei reinen Software-Flags Überhaupt nicht.

Ist es das hier?

Lars schrieb:
> for ...
>   SDA  = transbit;        // To Start transfer From Highest bit
...
>   transdata = transdata<<1;      // One bit left shift

Ich denke, die Bit-Position ist hier nicht unwichtig.

Und generell, wenn der µC einen BIT-adressierbaren RAM-Bereich hat, ist 
das von entscheidender Bedeutung!
Wie wird auf ein C 'Bit-Feld' zugegriffen? Und wie macht der µC das wohl 
im Keilschen bdata? Warum hat der µC wohl ein 'bdata' Bereich? 
Geschwindigkeit ist keine Hexerei ...

[Carl D. (jcw2)]

Bit By Bit schrieb:
> Carl D. schrieb:
>> Das interessiert doch bei reinen Software-Flags Überhaupt nicht.
>
> Ist es das hier?
>
> Lars schrieb:
>> for ...
>>   SDA  = transbit;        // To Start transfer From Highest bit
> ...
>>   transdata = transdata<<1;      // One bit left shift
>
> Ich denke, die Bit-Position ist hier nicht unwichtig.
>
> Und generell, wenn der µC einen BIT-adressierbaren RAM-Bereich hat, ist
> das von entscheidender Bedeutung!
> Wie wird auf ein C 'Bit-Feld' zugegriffen? Und wie macht der µC das wohl
> im Keilschen bdata? Warum hat der µC wohl ein 'bdata' Bereich?
> Geschwindigkeit ist keine Hexerei ...

Also braucht man gar keine Bitvariable sondern einfach nur:

SDA = (transdata&0x80)?1:0;

Da der GCC übersetzen soll: welcher der von ihm unterstützten μC hat 
"bdata"?

[Bit By Bit (Gast)]

Oder SDA = (trans... & 0x80) != 0; oder, oder, ...
Viele Wege führen nach Rom.

Na siehste, geht doch.
Zum uC ließ die Beiträge oder benutze Google.