[avr-gcc] PORT Definition in einer Liste speichern

[Markus B. (markus_b77)]

Hi, ich stehe gerade vor einem Problem. Ich möchte eine Liste mit Ports 
und Pins anlegen. Eigentlich ein zweidimensionales Array. Nur mal als 
Beispiel zur Veranschaulichung

liste = {{PORTB, 1},
         {PORTB, 2},
         {PORTD, 1},
         {usw}
        };

Ich möchte diese Liste durchlaufen und jede Zeile an eine Funktion 
übergeben, die dann mit PORTB Pin 1 etwas tut.

Nur wie? Ich hab schon alles mögliche probiert. Ich weiß, dass ich PORTB 
so nicht direkt angeben kann, weil das ein Makro ist und ja versuchen 
würde, den Inhalt des PORT Registers zu lesen. Mit dem Adressoperator 
hat man auch keinen Erfolg.

Wie kann ich das Problem lösen?

[Klaus W. (mfgkw)]

PORTB ist zwar ein Makro, aber eines in der Art:

#define   PORTB   *(uint8_t*)20

(die 20 ist jetzt nur ein Beispiel; tatsächlich muß man sich dafür die 
tatsächliche Adresse denken, an der PORTB in den Speicher eingeblendet 
wird - je nach konkretem AVR.)

PORTB expandiert also zu einer Referenz auf eine Speicherstelle, also 
wie eine Variable, die an der Stelle 20 im Speicher liegt.

Das wiederum heißt, daß man davon auch die Adresse nehmen kann.
Du musst aber bereits in deinem Feld Adressen eintragen, also
etwa so:

typedef struct
{
   uint8_t   *p_port;
   uint8_t    pin;
} port_pin_paar_t;

port_pin_paar_t liste[] = { { &PORTB, 1 },
                            { &PORTB, 2 },
                            { &PORTD, 1 },
                            {usw}
                          };

// Zugriff:
f1( liste[0] );
f1( &liste[0] );
...

void f1( port_pin_paar_t port_pin_paar )
{
    // Bit setzen:
    *(port_pin_paar.p_port) |= (1<<port_pin_paar.pin);
}

void f2( const port_pin_paar_t *p_port_pin_paar )
{
    // Bit setzen:
    *(p_port_pin_paar->p_port) |= (1<<p_port_pin_paar->pin);
}

[Markus B. (markus_b77)]

Danke für die Erklärung. Wenn ich dein Beispiel jedoch übernehme bekomme 
ich folgenden Fehler

main.cpp:19: error: invalid conversion from 'volatile uint8_t*' to 
'uint8_t*'

Wenn ich in der Struct folgendes ändere funktioniert es.

typedef struct
{
   volatile uint8_t   *p_port;
   uint8_t    pin;
} port_pin_paar_t;

Ist das richtig so?

[Klaus W. (mfgkw)]

ja

Das volatile hatte ich schändlicherweise unterschlagen.

[Klaus W. (mfgkw)]

Musst du jetzt noch in offenen Wunden bohren? :-)

[Markus B. (markus_b77)]

:)

Danke

[Stefan E. (sternst)]

Klaus Wachtler schrieb:
> Musst du jetzt noch in offenen Wunden bohren? :-)

Mein Gott bist du schnell. Der Beitrag war doch gerade mal 10 Sekunden 
da. ;-)

[Klaus W. (mfgkw)]

Stefan Ernst schrieb:
> bist du schnell

Wir sind hier bei C, und nicht bei C#, Java oder BASIC.

[Markus B. (markus_b77)]

Eins noch

// Zugriff:
f1( liste[0] );
f1( &liste[0] );

sollte wohl

// Zugriff:
f1( liste[0] );
f2( &liste[0] );

heißen

[Klaus W. (mfgkw)]

ja, das war wiederum zu schnell :-(

[Markus B. (markus_b77)]

Fehler passieren. Am besten du korrigierst deinen Beitrag, falls später 
mal jemand darüber stolpert und nicht den ganzen Beitrag ließt

[Klaus W. (mfgkw)]

Im Originaltext kann ich nichts mehr korrigieren, sobald eine Antwort 
dahinter steht.

Wer nicht bis zum Ende liest, hat dann Pech.

[Markus B. (markus_b77)]

Eine Frage noch. Die Liste müsste ins Flash, weil die doch etwas länger 
wird. Wie lege ich das an? Einfach ein PROGMEM anhängen geht nich. Und 
wie greife ich darauf zu?

[Stefan E. (sternst)]

Markus B. schrieb:
> Eine Frage noch. Die Liste müsste ins Flash, weil die doch etwas länger
> wird. Wie lege ich das an? Einfach ein PROGMEM anhängen geht nich. Und
> wie greife ich darauf zu?

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmspeicher_.28Flash.29

[Markus B. (markus_b77)]

Da war ich schon. Bekomme aber wie gesagt eine Fehlermeldung

> main.cpp:32: warning: only initialized variables can be placed into
> program memory area

const testpin_t liste[] PROGMEM =

[Markus B. (markus_b77)]

Hier mal der komplette Code

typedef struct
{
   volatile uint8_t   *p_portT;
      uint8_t    pinT;
   volatile uint8_t   *p_portL;
      uint8_t    pinL;
   volatile uint8_t   *p_portR;
      uint8_t    pinR;
   volatile uint8_t   *p_portC;
      uint8_t    pinC;
} testpin_t;

const testpin_t liste[] PROGMEM = 
{
  { &PORTE, 0, &PORTE, 1, 0, 0, &PORTD, 2}
}

[fluch (Gast)]

Tu mal die [] da weg.

[fluch (Gast)]

(und eine Ladung geschweifte Klammern)

[Markus B. (markus_b77)]

fluch schrieb:
> Tu mal die [] da weg.
Dann kommen nur noch Fehler

fluch schrieb:
> (und eine Ladung geschweifte Klammern)

???

[fluch (Gast)]

const testpin_t liste PROGMEM = { &PORTE, 0, &PORTE, 1, 0, 0, &PORTD, 2};

[Markus B. (markus_b77)]

Sorry, ich dachte aufgrund des restlichen Threads wäre klar, dass es 
mehrere Einträge gibt.

const testpin_t liste[] PROGMEM = 
{
  { &PORTE, 0, &PORTE, 1, 0, 0, &PORTD, 2},
  { &PORTE, 0, 0, 0, 0, 0, &PORTD, 2},
  { &PORTE, 0, 0, 0, &PORTE, 1, &PORTD, 2},
  { &PORTE, 0, &PORTE, 1, &PORTE, 1, &PORTD, 2},
  { &PORTE, 0, &PORTE, 1, &PORTE, 1, &PORTD, 2}
}

[fluch (Gast)]

Ah ok. Dann schreib mal die Anzahl in die eckigen Klammern rein, wenn 
das nicht hilft muss Karl-Heinz oder ein anderer Spezi ran...

[Markus B. (markus_b77)]

Nein, nach wie vor die Fehlermeldung

> main.cpp:32: warning: only initialized variables can be placed into
> program memory area

[Fabian G. (kjion)]

Markus B. schrieb:
> Nein, nach wie vor die Fehlermeldung
>
>> main.cpp:32: warning: only initialized variables can be placed into
>> program memory area

Du compilierst das als C++?
Die Meldung ist ein Fehler in avr-g++.

Siehe Beitrag "avr-gcc, C++ und PROGMEM"

Workaround:

extern const testpin_t liste[] PROGMEM;
const testpin_t liste[] = 
{
  { &PORTE, 0, &PORTE, 1, 0, 0, &PORTD, 2},
  { &PORTE, 0, 0, 0, 0, 0, &PORTD, 2},
  { &PORTE, 0, 0, 0, &PORTE, 1, &PORTD, 2},
  { &PORTE, 0, &PORTE, 1, &PORTE, 1, &PORTD, 2},
  { &PORTE, 0, &PORTE, 1, &PORTE, 1, &PORTD, 2}
};

Auch wenn es komisch aussieht funktioniert es so.

Grüße Fabian

[Markus B. (markus_b77)]

Tatsache. Danke. Hab gar nicht daran gedacht, dass ich mit g++ 
compiliere.

Jetzt fehlt noch das lesen einer Struct aus dem Array. Das fehlt leider 
noch im Wiki

[Karl H. (kbuchegg)]

Markus B. schrieb:
> Tatsache. Danke. Hab gar nicht daran gedacht, dass ich mit g++
> compiliere.
>
> Jetzt fehlt noch das lesen einer Struct aus dem Array. Das fehlt leider
> noch im Wiki

Einfach in einer Schleife sizeof(testpin_t) Bytes aus dem Flash lesen 
und auf einer im SRAM bereitgestellten testpin_t Variable ablegen. Dazu 
muss man ein wenig casten.

Man kann dazu zb die Funktion memcpy_P() sinnvoll benutzen.

[Klaus W. (mfgkw)]

Markus B. schrieb:
> Jetzt fehlt noch das lesen einer Struct aus dem Array. Das fehlt leider
> noch im Wiki

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmspeicher_.28Flash.29

[Klaus W. (mfgkw)]

Ich habe mir erlaubt, die obige Diskussion ins Tutorial zu übernehmen:
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Speichern_und_.C3.9Cbergeben_von_Port_und_Pinnummer

(mit volatile natürlich)

[Markus B. (markus_b77)]

Zur Berechnung von DDR und PIN gibt es ein kleines Makro. Die Lösung im 
Wiki funktioniert beim Mega128 PortF nicht

#define DDR(x) (*(&x - 1))
#if defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__)
    #define PIN(x) ( &PORTF==&(x) ? _SFR_IO8(0x00) : (*(&x - 2)) )
#else
    #define PIN(x) (*(&x - 2))
#endif

[Markus B. (markus_b77)]

@Klaus: ich meine den Teil

> TODO: Beispiele für structs und pointer aus Flash auf struct im Flash
> (menues, state-machines etc.).

[Klaus W. (mfgkw)]

oh, das ist ja blöd.

Danke!

[Klaus W. (mfgkw)]

Markus B. schrieb:
> @Klaus: ich meine den Teil
>
>> TODO: Beispiele für structs und pointer aus Flash auf struct im Flash
>> (menues, state-machines etc.).

Daran habe ich aber gar nichts geändert?
Aus meinem Teil von eben 
(http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Speichern_und_.C3.9Cbergeben_von_Port_und_Pinnummer) 
habe ich den DDR-Teil wieder entfernt.

[Klaus W. (mfgkw)]

Klaus Wachtler schrieb:
> Markus B. schrieb:
>> Jetzt fehlt noch das lesen einer Struct aus dem Array. Das fehlt leider
>> noch im Wiki
>
> 
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmspeicher_.28Flash.29

Sorry für die schroff kurze Antwort; als du nachgesehen hattest, gab es 
die Stelle im Tutorial tatsächlich noch nicht.
(Gut daß ich nicht deutlicher gelästert hatte über mangelndes Bemühen 
beim Suchen, es lag mir ja auf der Zunge :-)

Das hat Karl-Heinz da gerade schnell reingebaut (Danke!).

Wehe, es beschwert sich noch mal jemand über schlechten Service hier!

[Markus B. (markus_b77)]

Klaus Wachtler schrieb:
> Das hat Karl-Heinz da gerade schnell reingebaut (Danke!).

Ach da unten. Ich hatte den neuen Eintrag wohl gesehen, den Teil aber 
übersehen. Hab noch keinen Kaffee :)

[Johann L. (gjlayde)]

Klaus Wachtler schrieb:
> Ich habe mir erlaubt, die obige Diskussion ins Tutorial zu übernehmen:
> 
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Speichern_und_.C3.9Cbergeben_von_Port_und_Pinnummer

Inzwischen ist das Tutorial wohl so unübersichtlich, daß ein und 
dasselbe x-mal erklärt wird:

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#IO-Register_als_Parameter_und_Variablen
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Speichern_und_.C3.9Cbergeben_von_Port_und_Pinnummer

Und warum extra erklärt wird, wie man das in Flash legt, ist doch total 
unnötig. Oder soll für jeden in C möglichen Tyedef erklört werden, wie 
man den ins Flash legt? Steht doch alles schon da:

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmspeicher_.28Flash.29

[Klaus W. (mfgkw)]

Sag das doch gleich; ist wieder weg.

[Klaus W. (mfgkw)]

Und wovon kommt's?
Weil die Leute dauernd fragen, ohne vorher danach zu suchen und das 
Tutorial zu lesen :-)

[Markus B. (markus_b77)]

Johann L. schrieb:
> Inzwischen ist das Tutorial wohl so unübersichtlich, daß ein und
> dasselbe x-mal erklärt wird:

Unübersichtlich? Ja. Ein und das selbe? Nein, finde ich nicht. Es gibt 
halt Menschen wie mich, die die nötigen Informationen aus dem Wust in 
dem Tutorial nicht finden und zusammenfügen können, weil die Erfahrung 
fehlt.

[Markus B. (markus_b77)]

Ich habe jetzt noch ein anderes Problem, das für mich keinen Sinn 
ergibt. Eventuell hat es was damit zu tun, dass ich mit dem g++ 
compiliere?

Hier erstmal der wichtige Code

typedef struct
{
   volatile uint8_t   *p_portT;
      uint8_t    pinT;
   volatile uint8_t   *p_portL;
      uint8_t    pinL;
   volatile uint8_t   *p_portR;
      uint8_t    pinR;
   volatile uint8_t   *p_portC;
      uint8_t    pinC;
} testpin_t;

testpin_t liste[] =
{
  { &PORTA, 0, &PORTA, 1, 0, 0, &PORTD, 2},
  { &PORTB, 0, 0, 0, 0, 0, &PORTD, 2},
  { &PORTC, 0, 0, 0, &PORTE, 1, &PORTD, 2},
  { &PORTD, 0, &PORTB, 1, &PORTE, 1, &PORTD, 2},
  { &PORTE, 0, &PORTC, 1, &PORTE, 1, &PORTD, 2},
  { 0, 0, 0, 0, 0, 0, 0, 0}
}

int main(void)
{
  sei();
  uint8_t i = 0;
  while(liste[i].p_portT)
  {
    stream << i << " ";
    stream << &liste[i] << " ";
    stream << *(liste[i].p_portL) << " ";
    stream << sizeof(liste[i]);
    i++;
    stream << xpcc::endl;
  }
  while (1)
  {
  }
  return 0;
}

&liste[i] gibt mir die Adresse des jeweiligen Struct aus. 
sizeof(liste[i]) ergibt interessanterweise 12 Byte, nicht 8, wie man 
erwarten würde. Braucht ein Struct 4 Byte extra? Oder brauchen die 
volatilen Felder ein extra Byte?

*(liste[i].p_portL) gibt jedoch völligen Blödsinn aus. Überall da, wo in 
der Liste ein &PORTx eingetragen ist, wird eine 0 ausgegeben. Da wo eine 
0 in der Liste steht erhalte ich aber einen Wert. Das ergibt überhaupt 
keinen Sinn und ich komme auch nicht dahinter, wieso.

Jemand eine Idee?

[Klaus W. (mfgkw)]

Markus B. schrieb:
> ergibt interessanterweise 12 Byte, nicht 8, wie man
> erwarten würde.

Ein Zeiger braucht auf einem bestimmten System immer eine feste Anzahl 
Byte, egal wie groß das ist, worauf er zeigt.
Bei AVR offenbar 2 Byte, auch wenn er auf eine ein Byte große uint8_t 
zeigt.

Vier Zeiger, 4 uint8_t macht zumsammen 12 Byte.

[Klaus W. (mfgkw)]

Wo nimmst du auf einem AVR streams her, und vor allem: willst du das 
wirklich?

[Klaus W. (mfgkw)]

Markus B. schrieb:
> Überall da, wo in
> der Liste ein &PORTx eingetragen ist, wird eine 0 ausgegeben.

Da, wo du eine &PORTx eingetragen hast, und mit * darauf zugreifst, 
bekommst du den aktuellen Wert von PORTx.
Auch wenn PORTx eigentlich zur Ausgabe gedacht ist, kannst du aus dem 
Register etwas lesen. Meines Wissens ist es der aktuelle ausgegebenen 
Wert, also 0, solange du nicht vorher mit PORTx = ... etwas anderes 
ausgibst.

[Markus B. (markus_b77)]

Klaus Wachtler schrieb:
> Wo nimmst du auf einem AVR streams her, und vor allem: willst du das
> wirklich?
http://xpcc.sourceforge.net/

Klaus Wachtler schrieb:
> Ein Zeiger braucht auf einem bestimmten System immer eine feste Anzahl
> Byte, egal wie groß das ist, worauf er zeigt.
> Bei AVR offenbar 2 Byte, auch wenn er auf eine ein Byte große uint8_t
> zeigt.

Ist ja kein uint8_t sondern ein Zeiger auf uint8_t. Das passiert, wenn 
man zu wenig geschlafen hat.

Trotzdem bekomme ich immer den Wert 0, sobald ich einen Port in die 
Liste schreibe. Komme nicht dahinter, warum.

[Klaus W. (mfgkw)]

Daß du in den anderen Fällen irgendwelche Werte bekommst, liegt daran, 
daß du den Zeiger mit 0 intialisierst, aber trotzdem mit *(uint8_t)0 
dann darauf zugreifst. Je nach AVR (siehe Datenblatt) wird da auch ein 
Register sein, dessen Wert du ausgibst.
Böser Junge!

[Stefan E. (sternst)]

Markus B. schrieb:
> Überall da, wo in
> der Liste ein &PORTx eingetragen ist, wird eine 0 ausgegeben.

Du hast ja auch nichts in die Port-Register geschrieben, und 0 ist der 
Default-Inhalt.

Markus B. schrieb:
> Da wo eine
> 0 in der Liste steht erhalte ich aber einen Wert.

Ja, den Inhalt von Adresse 0.

[Markus B. (markus_b77)]

Klaus Wachtler schrieb:
> Da, wo du eine &PORTx eingetragen hast, und mit * darauf zugreifst,
> bekommst du den aktuellen Wert von PORTx.
> Auch wenn PORTx eigentlich zur Ausgabe gedacht ist, kannst du aus dem
> Register etwas lesen. Meines Wissens ist es der aktuelle ausgegebenen
> Wert, also 0, solange du nicht vorher mit PORTx = ... etwas anderes
> ausgibst.

Man, ich hab heute Watte im Schädel. Danke