Schreiben in der Adresse geht nicht

[gast (Gast)]

hallo,
ich versuche die ganze Woche mit Hilfe der Adresse in  Register zu lesen 
und zu schreiben.
Mit Hilfe einer Struktur, die aus Adresse und Value besteht, will ich 
der Inhalt einer Register auslesen und an dieser Adresse des Registers 
einen neuen Wert schreiben.
Bei Ausführen des Programms klappt nicht.
Das erste auslesen ist richtig, aber wenn ich etwas an der Adresse 
schreibe, bekomme ich immer der alten Wert beim Lesen.

danke euch

[Sebastian H. (sebihepp)]

Hallo,

also entweder benutzt du globale Variablen für den Parameter oder
du nimmst den Funktionsparameter dafür. Hier hast du beides, benutzt
aber nur den globalen. Desweiteren sollten noch die Funktions-
deklarationen in der io.h stehen.

Der eigentliche Fehler den du meinst, liegt darin dass du in der
Funktion writeIORegister(...) zwar einen Zeiger auf den Speicher-
bereich erzeugst, aber nicht darauf schreibst. Es fehlt also noch ein

*Ptr_Reg = Val_Reg;

 am Ende.

Viele Grüße
Sebihepp

[gast (Gast)]

hallo,
ich habe festgstellt, dass ich letze mal paar Fehler gemacht habe.Jetzt 
habe ich das kleine Programm aufgeräumt.
Wie ich schon gesagt habe, versuche ich paar Werte in Adresse zu 
schreiben, leider klappt nicht.
Kann jemanden mir helfen.
Anbei das Programm.
danke

[Karl H. (kbuchegg)]

gast schrieb:
> hallo,
> ich habe festgstellt, dass ich letze mal paar Fehler gemacht habe.Jetzt
> habe ich das kleine Programm aufgeräumt.
> Wie ich schon gesagt habe, versuche ich paar Werte in Adresse zu
> schreiben, leider klappt nicht.

Dann räum erst mal kräftig auf

Aber sehen wir uns doch mal die Funktion an

 void writeIORegister(struct InOut *ptr_InOut)
 {  
   Adr_Reg = (uint8_t) (ptr_InOut->Adresse & 0xFF);
   Val_Reg = (uint8_t) (ptr_InOut->Value & 0xFF);
        //*Ptr_Reg = ((volatile uint8_t *) ((uint8_t) Val_Reg & 0xFF));
         *Ptr_Reg = Val_Reg;
         printf("the value %x will be written in adresse %p", Val_Reg,Adr_Reg);
  
 }

Hmm.
Da wird wie wild zugewiesen.
Aber letztendlich wird über *Ptr_Ref der neue Wert zugewiesen.
Nur: Wie kommt eigentlich Ptr_Reg zu seinem Wert?

Du trickst dich hier mit deinen ganzen Zwischenvariablen (die noch dazu 
ohne Grund global sind) permanent selber aus indem du dir Information 
konsequent vor dir selber versteckst.

void writeIORegister(struct InOut *ptr_InOut)
{
  uint8_t* Address = (uint8_t*)(ptr_InOut->Adresse & 0xFF);
  *Address = (uint8_t) (ptr_InOut->Value & 0xFF);
}

Ob das allerdings das korrekte Gegenstück zur read Funktion ist, kann 
ich nicht sagen, denn dort wird noch ein _MMIO_BYTE benutzt um an die 
Werte zu kommen.

[gast (Gast)]

hallo,

ich habe auch vorher mit _MMIO_BYTE( (Adr_Reg)) = 0xAA;und er hat auch 
nicht geklappt.

[Karl H. (kbuchegg)]

gast schrieb:
> hallo,
>
> ich habe auch vorher mit _MMIO_BYTE( (Adr_Reg)) = 0xAA;und er hat auch
> nicht geklappt.

Dazu kann man wenig sagen, weil _MMIO_BYTE ein Makro ist, das wir nicht 
kennen. Aber so wie das Makro beim read eingesetzt wird, wundert mich 
das wenig, dass damit das Schreiben nicht funktioniert.

Funktioniert eigentlich der read?

[gast (Gast)]

ja, das read funktionniert gut, in jeder Adresse lese ich den richtigen 
wert aus.

[Karl H. (kbuchegg)]

Dann such doch mal das Makro raus.
Ohne Kenntnis der Details ist das immer so ein Rätselraten.

Vielleicht kann man es ja auch zum Schreiben benutzen. Das weiß man aber 
erst, wenn man den Code sieht.

[gast (Gast)]

hallo Karl,
das Mokro ist in header file sfr_defs.h definiert.

[Karl H. (kbuchegg)]

Sag doch gleich, dass du mit dem gcc auf einem AVR arbeitest :-)

Dann sollte aber

void writeIORegister(struct InOut *ptr_InOut)
{
  _MMIO_BYTE( ptr_InOut->Adresse & 0xFF ) = (ptr_InOut->Value & 0xFF);
}

aber schon das Gegenstück zu deinem read sein.

[gast (Gast)]

hallo Karl,

bitte nicht böse  sein,aber ich bekomme gar nicht. was mache ich mit dem 
*Ptr_Reg?

[Karl H. (kbuchegg)]

Gar nichts.
Wer braucht das denn?

[gast (Gast)]

ich frage, weil ich immer der ursprunchliche Werte bekomme, nachdem ich 
geschrieben habe. Dh beim zweitem Aufruf der Funktion read, lese ich 
immer 0xfb  statt 0xAA;

[Karl H. (kbuchegg)]

Welches Register liest du denn aus?
Also welchen Zahlenwert hat denn die Adresse? Und welchem Register in 
üblicher Nomenklatur entspricht diese Adresse deiner Meinung nach auf 
deinem Prozessor? Und um welchen Prozessor handelt es sich überhaupt?

[gast (Gast)]

Ich lese den Register DDRC mit der Adresse 0x27

[Karl H. (kbuchegg)]

Auf welchem Prozessor?

[gast (Gast)]

die Adresse des Register habe ich im header file iocanxx.h gefunden.

[gast (Gast)]

ich benutze den Mikrocontroller AT90CAN128 von Atmel

[Karl H. (kbuchegg)]

Gerade ausprobiert

#include <avr/io.h>

int main()
{
  uint8_t j = 0xFF;
  uint8_t k;

  _MMIO_BYTE( 0x27 ) = 0x55;

  k = _MMIO_BYTE( 0x27 );

  return 0;
}

mit einem AT90CAN128
Funktioniert wie erwartet und der Simulator zeigt mir auch, dass sich 
tatsächlich das DDRC Register verändert hat (mit dem erwartetem Wert).

[gast (Gast)]

hi Karl,
vielleicht bekomme ich den falschen Wert, weil ich diese Warnung habe.
warning: cast to pointer from integer of different size
wegen _MMIO_BYTE( ptr_InOut->Adresse & 0xFF ) = (ptr_InOut->Value & 
0xFF);

[gast (Gast)]

hi Karl,
ich habe das Problem localisiert.
das DDRC ist richtig im write-Funktion aber nicht in read-Funktion (nur 
für den ersten Aufruf).

1.Aufruf read-Funktion

value=0xfb
value1=0xff
DDRC=0xfb

2.Aufruf write -Funktion

k=0xAA
DDRC=0xAA

3.Aufruf read-Funktion

value=0xfb
value1=0xff
DDRC=0xfb