Zugriff und Zuweisung auf ein Array das aus struct besteht

[Hans Schmidt (Gast)]

Hallo,

probiere gerade meine bisherigen Funktionen ein wenig genereller zu 
gestalten. Habe vier (Luft-)Pumpen mit zugehöriger Sensorik an einem AVR 
hängen, d.h. zu einer Pumpe gehört genau ein Sensor usw. so dass sich 
quasi immer ein zusammenhängendes Konstrukt ergibt wenn Statusänderungen 
anstehen. Daher würde ich gerne über ein array das aus einem struct 
besteht darauf zugreifen um es später auch noch zu verstehen. Denn ein 
"setze an Portx den Pinx = 1" verstehe ich nicht, während hingegen ein 
setze an Portx den Pin kanal_daten[0].on_off_pin (für mich) 
verständlicher ist.
Scheitere aber schon bei der Zuweisung/Befüllung. Was mache ich falsch, 
bzw. wie geht es richtig?

Gruß, Hans

#include <stdlib.h>
// Anzahl an Kanaelen
#define MAX_CH 4
// Aufzaehlung fuer die verfuegbaren Kanaele
enum nutzbare_kanaele {CH1=1, CH2=2, CH3=3, CH4=4};
// structure fuer Infos zum Anschluss der HW
struct kanal_info {
  enum nutzbare_kanaele nummer;
  uint8_t on_off_pin;
  uint8_t flowcontrol_pin;
  uint8_t pwm_pin;
  uint8_t pwm_timer;
};
// Array mit Infos/Daten fuer die Kanaele erstellen
struct kanal_info kanal_daten[MAX_CH];

// Beginn des Hauptprogrammes
int main(void)
{
  // Kanalinformationen in die Variable schreiben
  struct kanal_info kanal_daten[0] = {CH1, PIND7, PINC0, PIND6, OCR0A};
  struct kanal_info kanal_daten[1] = {CH2, PIND2, PINC1, PIND5, OCR0B};
  struct kanal_info kanal_daten[2] = {CH3, PINC4, PINC2, PIND3, OCR2B};
  struct kanal_info kanal_daten[3] = {CH4, PINC5, PINC3, PINB3, OCR2A};
  while (1)
  {

  }
  // für korrekte Syntax was zurückgeben
  return 0;
}

[Wilhelm M. (wimalopaan)]

Du solltest erst mal schauen, wie man einem Array-Element etwas zuweist.

[Wilhelm M. (wimalopaan)]

Hans Schmidt schrieb:
> // für korrekte Syntax was zurückgeben
>   return 0;

Nicht notwendig: main() ist in verschiedenen Aspekten besonders.

[Oliver S. (oliverso)]

Hans Schmidt schrieb:
> Scheitere aber schon bei der Zuweisung/Befüllung. Was mache ich falsch

Das sagt dir eigentlich der Compiler.

Schau dir dazu auch mal an, wie OCR0A etc. definiert ist. Das ist kein 
uint8_t.

Oliver

[Hans Schmidt (Gast)]

Hmmm, stehe leider weiter auf dem Schlauch...
@Wilhelm: na ja, normalerweise schreibe ich so etwas wie 
meinArray[meinIndex] = gewünschterWert
Aber in einer Anleitung hieß es, ich muss immer das struct davor 
schreiben. Eine Alternative wäre es per typedef einen neuen Typen zu 
definieren. Das hatte ich aber nicht gemacht, um immer in Erinnerung zu 
behalten: das ist ein struct.
Zum return Wert: eine (ur-)alte Version eines AVR Compilers hatte das 
mal angemeckert. Gerade ausprobiert und wird aktuell tatsächlich nicht 
angemahnt ==> fliegt demnächst raus.
@Oliver: Bei mir sind die ganzen Pins und Register defines die vom Wert 
her in einen unit8 passen würden.

#define OCR0A   _SFR_IO8(0x27)

Ich habe nur keine Ahnung was hinter dem eigentlichen define/dem special 
functions register IO8 steht, evtl. ist da auch ein weiterer Fehler weil 
dies den Wert 0x27=39dez noch einmal "aufbläht"

Bin leider so schlau wie vorher... Könnt ihr mir bitte noch einen Wink 
mit dem Zaunpfahl geben?

[Oliver S. (oliverso)]

Ich spende mal ein

#include <avr/io.h>

Oliver

[Armin J. (arminj)]

Hier mal ein Beispiel:

const struct IRToCommandMappingStruct IRMapping[] ={
{COMMAND_BLINK, IR_COMMAND_FLAG_REGULAR, &doLedBlink20times, blink20times },
{COMMAND_ON, IR_COMMAND_FLAG_REGULAR, &doLedOn, LEDon }
};

[Wilhelm M. (wimalopaan)]

Hans Schmidt schrieb:
> @Wilhelm: na ja, normalerweise schreibe ich so etwas wie
> meinArray[meinIndex] = gewünschterWert

Und genau das steht bei Dir eben nicht.

Bei Dir steht (in etwa)

datatype meinArray[meinIndex] = gewünschterWert;

[Wilhelm M. (wimalopaan)]

Hans Schmidt schrieb:
> @Oliver: Bei mir sind die ganzen Pins und Register defines die vom Wert
> her in einen unit8 passen würden.#define OCR0A   _SFR_IO8(0x27)

Dann schau doch mal nach ;-)

[Wilhelm M. (wimalopaan)]

Armin J. schrieb:
> const struct IRToCommandMappingStruct IRMapping[] ={
> {COMMAND_BLINK, IR_COMMAND_FLAG_REGULAR, &doLedBlink20times,
> blink20times },
> {COMMAND_ON, IR_COMMAND_FLAG_REGULAR, &doLedOn, LEDon }
> };

Und das ist keine Wertzuweisung, so wie er es machen möchte ...

[Rolf M. (rmagnus)]

Wilhelm M. schrieb:
> Und das ist keine Wertzuweisung, so wie er es machen möchte ...

Möchte er das?  Oder macht er das nur, weil er nicht weiß, wie eine 
richtige Initialisierung geht?
Aber gut, auch Zuweisung geht.

kanal_daten[0] = (struct kanal_info){CH1, PIND7, PINC0, PIND6, OCR0A};

Wilhelm M. schrieb:
> Hans Schmidt schrieb:
>> // für korrekte Syntax was zurückgeben
>>   return 0;
>
> Nicht notwendig: main() ist in verschiedenen Aspekten besonders.

Eine eher überflüssigen Regel, die man auch nicht unbedingt kennen muss.

[Hans Schmidt (Gast)]

Hallo,

@Oliver: mein Fehler. Ja, das muss natürlich rein, sonst sind die 
Pindefinitionen nicht dabei. Da habe ich zu viel eingekürzt.
@Armin: danke dir. Da die Zuordnung konstant ist (spiegelt ja die HW 
Anschlüsse wieder), reicht hier in der Tat eine "Konstante" auch aus und 
ist sogar vermutlich die bessere Wahl
@Wilhelm: ja, das weiß ich. Das hatte ich aber wie gesagt bewusst so 
gemacht. Hatte mich an der Stelle an diese Erklärung hier gehalten:
http://c-buch.sommergut.de/Kapitel13/Strukturen.shtml
Abschnitt Arrays aus Strukturen

/* nur eine Struktur initialisieren */
struct adresse kunden[100]={
  {"Enn", "Georg", 236324, 43788}
  };

Dort steht grob gesagt "immer struct" davor
Habe zuerst die avr/sfr_defs.h nciht gefunden, die sagt mir

#define _SFR_IO8(io_addr) _MMIO_BYTE((io_addr) + __SFR_OFFSET)
#define _MMIO_BYTE(mem_addr) (*(volatile uint8_t *)(mem_addr))

#  if __AVR_ARCH__ >= 100
#    define __SFR_OFFSET 0x00
#  else
#    define __SFR_OFFSET 0x20
#  endif

demnach ist das OCR0A:

(*(volatile uint8_t *)(0x27 + __SFR_OFFSET))

@Rolf: danke dir

Guten Start in den Tag, Hans

[Rolf M. (rmagnus)]

Hans Schmidt schrieb:
> Abschnitt Arrays aus Strukturen/* nur eine Struktur initialisieren */
> struct adresse kunden[100]={
>   {"Enn", "Georg", 236324, 43788}
>   };
> Dort steht grob gesagt "immer struct" davor

Nein, es steht genau einmal davor - bei der Definition des Arrays.
Das wäre bei dir der Teil:

Hans Schmidt schrieb:
> // Array mit Infos/Daten fuer die Kanaele erstellen
> struct kanal_info kanal_daten[MAX_CH];

Und danach versuchst du, lauter neue Arrays mit gleichem Namen zu 
definieren,  eins mit 0 Elementen, eins mit einem Element u.s.w.:

>   // Kanalinformationen in die Variable schreiben
>   struct kanal_info kanal_daten[0] = {CH1, PIND7, PINC0, PIND6, OCR0A};
>   struct kanal_info kanal_daten[1] = {CH2, PIND2, PINC1, PIND5, OCR0B};
>   struct kanal_info kanal_daten[2] = {CH3, PINC4, PINC2, PIND3, OCR2B};
>   struct kanal_info kanal_daten[3] = {CH4, PINC5, PINC3, PINB3, OCR2A};

Du musst lernen, was in C die drei Begriffe Definition, Initialisierung 
und Zuweisung bedeuten. Denn das obige Beispiel nutzt eine Definition 
mit Initialisierung. Du nutzt eine Definition ohne Initialisierung, 
dafür machst du nachher Zuweisungen, die du aber so schreibst wie 
Initialisierungen.

Einfach gesagt:

Typ Name; // Definition
Typ Name = Wert; // Definition mit Initialisierung
Name = Wert; // Zuweisung

[Hans Schmidt (Gast)]

Hallo Rolf,

danke dir für die Klarstellung.
Dann ist das Beipiel in dem von mir gewählten Link "unglücklich", bzw. 
weil immer nur Codeschnipsel da stehen aus dem Zusammenhang gerissen. 
Denn dort gibt es dann doch auch eine Re-Definition, oder? Zuerst 100 
Elemente (0...99) und dann eine Re-Defintion mit Initialisierung. Oder 
kapiere ich es immer noch nicht?

struct adresse{
  char szName[30];
  char szVorname[30];
  unsigned long ulTel;
  unsigned long ulPlz;
  };

/* Array aus 100 Strukturen vom
 * Typ adresse
 */
struct adresse kunden[100];

// [...]

/* nur eine Struktur initialisieren */
struct adresse kunden[100]={
  {"Enn", "Georg", 236324, 43788}
  };

[Rolf M. (rmagnus)]

Hans Schmidt schrieb:
> Zuerst 100 Elemente (0...99) und dann eine Re-Defintion mit
> Initialisierung. Oder kapiere ich es immer noch nicht?

Im Prinzip ist das richtig. Allerdings darfst du es nicht zweimal 
definieren.  Du müsstes die erste Definition also weglassen.
Hier kommt dann noch eine weitere Sache hinzu: Die Deklaration. Damit 
wird nur der Name und Typ einer Variablen bekannt gemacht, aber sie wird 
noch nicht erstellt.

[Wilhelm M. (wimalopaan)]

Rolf M. schrieb:
> Eine eher überflüssigen Regel, die man auch nicht unbedingt kennen muss.

Das main() aber 2 (-3) Signaturen hat, sollte man aber schon kennen.

[Wilhelm M. (wimalopaan)]

Hans Schmidt schrieb:
> Denn dort gibt es dann doch auch eine Re-Definition, oder?

Mache Dir den Unterschied zwischen Deklaration und Definition klar. Ist 
absolut zentral in C/C++. Schaue mal nach ODR (one-definition-rule).
Als Eselsbrücke: für eine Definition benötigt der Compiler irgendwie 
Speicher (für Variable, Funktionskörper, ...), bei einer Deklaration 
wird nur der Name/Typ eines Symbols bekannt gemacht.

[Ralf G. (ralg)]

Hans Schmidt schrieb:
>   /* nur eine Struktur initialisieren */
>   struct adresse kunden[100]={
>   {"Enn", "Georg", 236324, 43788}
>   };

Rolf M. schrieb:
> Einfach gesagt:
>  Typ Name; // Definition
>  Typ Name = Wert; // Definition mit Initialisierung
>  Name = Wert; // Zuweisung

@Hans
Was du oben machst, ist die "Definition mit Initialisierung". Allerdings 
für das erste Element (Index '0'!!) von 100 Elementen. Aber: das darf 
nur einmal vorkommen. Die Variable "kunden" ist aber vorher schon 
definiert worden. Dir bleibt in dem Fall nur die "Zuweisung":

Rolf M. schrieb:
> Aber gut, auch Zuweisung geht.

kunden[99] = (struct adresse){"Enn", "Georg", 236324, 43788}; // bei 100 Elementen ist '99' der letzte Index!

[Hans Schmidt (Gast)]

Hallo zusammen,

mir bleibt nur über zu sagen: DANKE!

Gruß, Hans