Ausdruck?

[Dirk (Gast)]

Moin,

ich hab hier einen Code für den GCC-Compiler und darin kommt dieser Term 
vor:

output(DDRD,input(DDRD)&0xEF);

Versteh dabei nicht ganz den Zusammenhang mit output und input 
eineinander verschachtelt. Einzeln bedeuten die Terme:

z.B: output(DDRD,0x90); => DDRD |= ((1 << PD7) | (1 << PB4));

      input(DDRD,0x07); => DDRD &= ~((1 << PD0) | (1 << PD1) | 1 << 
PD2));


Kann mir jemand erklären was der obere Ausdruck bewirkt?


Gruß  Dirk

[Oliver (Gast)]

DDRD lesen, Wert mit 0xFE ver-unden, Ergebnis ins DDRD schreiben.

Der Sinn der Aktion sollte sich aus dem Programm un der externen 
Beschaltung ergeben.

Oliver

[Joerg W. (joergwolfram)]

DDRD lesen, Bit 4 löschen und zurückschreiben -> Portd.4 als Eingang 
konfigurieren

[Rahul, der Trollige (Gast)]

>input(DDRD,0x07);
Gibbet nit!

input liefert(e) ein Byte zurück.
Also:  x = input(DDRD);

>output(DDRD,input(DDRD)&0xEF);
macht:
DDRD = DDRD & 0xEF;

>output(DDRD,0x90);
DDRD = ((1 << PD7) | (1 << PB3));

[Dirk (Gast)]

>> output(DDRD,input(DDRD)&0xEF);
> macht:
> DDRD = DDRD & 0xEF;

Das war verständlich, vielen Dank!

Hab da noch nen Part den ich nicht verstehe, vielleicht könnt ihr mir da 
noch einen Tip zu geben? Da steht folgendes:

uc_8 i;

i = input(SPL);                 //?Stack Pointer?
i ^= 0xFF;
extern ui_16 start;
extern ui_16 stack;
uc_8 *ptr = (uc_8*)&start;  //?
  while(ptr<(uc_8*)&stack - i)  //?
{
  *ptr++=0;                     //?
}

Die Zeilen die ich nicht verstehe hab ich mit einem 
Fragezeichenkommentar versehen.

Gruß

[Rahul, der Trollige (Gast)]

>i = input(SPL);                 //?Stack Pointer?
wirr...man müsste wissen, was SPL sein soll. Sowas sollte man sich 
i.d.R. aber sparen (können), da sich der Compiler um solche 
Angelegenheiten kümmert.

>extern ui_16 start;
>extern ui_16 stack;

>uc_8 *ptr = (uc_8*)&start;  //?
>  while(ptr<(uc_8*)&stack - i)  //?
>{
>  *ptr++=0;                     //?
>}

Es werden die aufeinanderfolgenden Speicherzellen bis zum Stackbeginn 
auf 0 gesetzt.
>uc_8 *ptr = (uc_8*)&start;  //?
ein Pointer vom Typ uc_8 wird vereinbart.
>(uc_8*)&start

Die Adresse von "start" wird zu einem Pointer vom Typ uc_8 gemacht, 
damit der Compiler nicht meckert ("type cast").
(Es handelt sich bei sämtlichen Operationen um 
Standard-C-Pointer-Grundlagen...

Der Mensch, der das Programm geschrieben hat, scheint von Assembler auf 
C umgestiegen zu sein.

[Dirk (Gast)]

>> i = input(SPL);                 //?Stack Pointer?
> wirr...man müsste wissen, was SPL sein soll.

Denke SPL(Stack Pointer Low) ist das Low-Byte vom Stack Pointer.

Das ist in der io.h definiert:

/*
 * AVR architecture 1 has no RAM, thus no stack pointer.
 *
 * All other archs do have a stack pointer.  Some devices have only
 * less than 256 bytes of possible RAM locations (128 Bytes of SRAM
 * and no option for external RAM), thus SPH is officially "reserved"
 * for them.  We catch this case below after including the
 * device-specific ioXXXX.h file, by examining XRAMEND, and
 * #undef-ining SP and SPH in that case.
 */
/* Stack Pointer */
#define SP        _SFR_IO16(0x3D)
#define SPL       _SFR_IO8(0x3D)
#define SPH       _SFR_IO8(0x3E)
#endif /* #if _AVR_ARCH_ != 1 */

Wozu das ganze gut ist, weiß ich leider nicht. Vielleicht kanst du mir 
das ja sagen.


Gruß

[Rahul, der Trollige (Gast)]

>i = input(SPL);                 //?Stack Pointer?
Lowbyte des Stackpointers

>i ^= 0xFF;
Komplett-Inversion des Bytes (i=~SPL;)

In welchem Zusammenhang (kmplettes Programm als Anhang vielleicht?!) 
findet man sowas?

[Dirk (Gast)]

Hi Rahul,

das komplette Programm kann ich leider nicht posten. Musste versprechen 
den Code nicht zu Veröffentlichen. Und daran möchte ich mich auch 
halten.
Sorry!

Es geht aber in diesem Teil der Software um die Initialisierung globaler 
Variablen. Was mir leider immer noch nicht klar ist, was dieser Part 
genau bezwecken soll.

Vor allem warum hier(uc_8 *ptr = (uc_8*)&start;), eine Integer Adresse 
einem Charactor Pointer zugewiesen wird.

Was mag das ganze für einen Sinn haben?

[Rahul, der Trollige (Gast)]

>Was mag das ganze für einen Sinn haben?
AVR sind 8Bitter. Deswegen gehen auch Pointer-Operationen auch mit uc_8 
(unsigned char) schneller als Word/16Bit)-Operationen.
Ist aber nur eine Vermutung meinerseits.
Es geht irgendwie darum, dein Speicher zwischen zwei bestimmten Marken 
zu löschen.
Wie oben schon erwähnt: Der Programmersteller scheint von Assembler auf 
C umgestiegen zu sein - das aber nicht konsequent genug.
Stack-Manipulationen in C sind "Bäh!" (sollte man tunlichst vermeiden).

[Dirk (Gast)]

Vielen Dank für die Hilfe.

Ist ist denn möglich diesen ganzen Teil ohne großen Aufwand 
umzuschreiben? Ohne großen Aufwand heißt, mit einigermaßen aber noch 
nicht so ordentlichen C-Porgrammierkenntnissen?