ANSI C - open() als Schleife

[Welle 🧐 S. (w3llschmidt)]

Hallo *!

kurze Frage, kann man das etwas smarter machen? Mit einer Schleife?

char gpio0[] = "17";
char gpio1[] = "18";
char gpio2[] = "21";

      snprintf(fn_gpio0, GPIO_FN_MAXLEN-1, "/sys/class/gpio/gpio%s/value", gpio0);
      fd_gpio0=open(fn_gpio0, O_RDONLY);
      if(fd_gpio0<0) 
      {
        perror(fn_gpio0);
        return 1;
      }
      
      snprintf(fn_gpio1, GPIO_FN_MAXLEN-1, "/sys/class/gpio/gpio%s/value", gpio1);
      fd_gpio1=open(fn_gpio1, O_RDONLY);
      if(fd_gpio1<0) 
      {
        perror(fn_gpio0);
        return 1;
      }
      snprintf(fn_gpio2, GPIO_FN_MAXLEN-1, "/sys/class/gpio/gpio%s/value", gpio2);
      fd_gpio2=open(fn_gpio2, O_RDONLY);
      if(fd_gpio2<0) 
      {
        perror(fn_gpio0);
        return 1;
      }

[Dennis H. (c-logic)]

for(z ............
{
 snprintf(fn_gpio[z], GPIO_FN_MAXLEN-1, "/sys/class/gpio/gpio%s/value", 
gpio[z]);
 n=open(fn_gpio[z], O_RDONLY);
 if(n<0)
 {
  perror(fn_gpio0);
  return 1;
 }
 else fd_gpio[....]=n;
}

[Welle 🧐 S. (w3llschmidt)]

Sieht schick aus, versuch ich gleich zu adaptieren! Danke Dennis!

[Welle 🧐 S. (w3llschmidt)]

Blöde Frage :-)

Kann ich die ->

close ( fd_gpio0 );
close ( fd_gpio1 );
close ( fd_gpio2 );
return 0;

auf die gleiche Weise auch wieder zu machen?

Oder ist das nicht so ein guter Stil?

[Dennis H. (c-logic)]

char gpio[][3] = {"17","18","21"};

Hast Du Ahnung vom Programmieren in C ?

[Dennis H. (c-logic)]

char gpio0[][3] = {"17","18","21"};
FILE (*fp)[3]={0};

//Öffnen

for(z=0;z<3;z++)
{
 char buffer[GPIO_FN_MAXLEN+1];
 snprintf(buffer, GPIO_FN_MAXLEN-1,
 "/sys/class/gpio/gpio%s/value",
 gpio[z]);
 FILE n=open(buffer,O_RDONLY);
 if(n<0)
 {
  perror(fn_gpio0);
  return 1; //Eventuell ein fp[z]=0;
 }
 else
  fp[z]=n;
}

//Schliessen
for(z=0;z<3;z++)
 if(fp[z])fclose(z);

[Welle 🧐 S. (w3llschmidt)]

Nee, ich weiss das sieht man :-)

[Dennis H. (c-logic)]

Eventuell sind da noch ein paar Fehler drin.

Aber im Prinzip ginge es so

char gpio0[][3] = {"17","18","21"};
FILE *fp[3]={0};

//Öffnen
int z;
for(z=0;z<3;z++)
{
 char buffer[GPIO_FN_MAXLEN+1];
 snprintf(buffer, GPIO_FN_MAXLEN-1, "/sys/class/gpio/gpio%s/value", 
gpio[z]);
 FILE *n=open(buffer,O_RDONLY);
 if(n<0)
 {
  perror(buffer);
  fp[z]=0;
 }
 else
  fp[z]=n;
}

//Schliessen
for(z=0;z<3;z++)
 if(fp[z])fclose(fp[z]);

[Welle 🧐 S. (w3llschmidt)]

Fummel ich mir hin :-)

---


Kannd das sein, das open() kein FILE mag?

311: FILE *n=open(buffer,O_RDONLY);

311:13: warning: initialization makes pointer from integer without a 
cast

[Dennis H. (c-logic)]

ah Linux
http://linux.die.net/man/2/open


nimm dann ein Array von int.

int fp[3]={0};

int n=open(buffer,O_RDONLY);

[Welle 🧐 S. (w3llschmidt)]

Hmm ... siehst Du n Fehler?

        char gpio[][3] = {"17","18","21"};
        int fp[3]={0};

        //Öffnen
        int z;
        for(z=0;z<3;z++)
        {
          char buffer[GPIO_FN_MAXLEN+1];
          snprintf(buffer, GPIO_FN_MAXLEN-1, "/sys/class/gpio/gpio%s/value", gpio[z]);
          int n=open(buffer,O_RDONLY);
          
          if(n<0)
          {
          perror(buffer);
          fp[z]=0;
          }
          else
          fp[z]=n;
        }

syslog(LOG_INFO, "%s", fd_gpio0);

Nov 24 00:24:33 rpi s0vz: (null)

[Dennis H. (c-logic)]

Funktionierts denn ?

[Welle 🧐 S. (w3llschmidt)]

Nee, leider nisch ... irgendwie ist der Filepointer leer ?!

[Welle 🧐 S. (w3llschmidt)]

Komisch

        char gpio[][3] = {"17","18","21"};
        int fd_gpio[3]={0};

        //Öffnen
        int z;
        for(z=0;z<3;z++)
        {
          char buffer[GPIO_FN_MAXLEN+1];
          snprintf(buffer, GPIO_FN_MAXLEN-1, "/sys/class/gpio/gpio%s/value", gpio[z]);
          syslog(LOG_INFO, "%s", buffer);
          int n=open(buffer,O_RDONLY);
          
          if(n<0)
          {
          perror(buffer);
          fd_gpio[z]=0;
          }
          else
          fd_gpio[z]=n;
        }

Das geht

Nov 24 00:56:16 rpi s0vz: /sys/class/gpio/gpio17/value
Nov 24 00:56:16 rpi s0vz: /sys/class/gpio/gpio18/value
Nov 24 00:56:16 rpi s0vz: /sys/class/gpio/gpio21/value

.

[Dennis H. (c-logic)]

fd_gpio[ ist leer ?
Wo ist fd_gpio definiert ?
Es hört sich für mich nach einem Gültigkeitsproblem an.
Zeig mal mehr Programmcode.

[Welle 🧐 S. (w3llschmidt)]

Das ist alles :-)

http://pastebin.com/gE3ymsSK

[Dennis H. (c-logic)]

fd_gpio0 kann übrigens keinen Sinnvollen Wert enthalten.

fd_gpio[0] allerdings schon.

[Welle 🧐 S. (w3llschmidt)]

Du meinst so ->

        char gpio[][3] = {"17","18","21"};
        int fd_gpio[3]={0};

        int z;
        for(z=0;z<3;z++)
        {
          char buffer[GPIO_FN_MAXLEN+1];
          snprintf(buffer, GPIO_FN_MAXLEN-1, "/sys/class/gpio/gpio%s/value", gpio[z]);
          int n=open(buffer,O_RDONLY);
          syslog(LOG_INFO, "%s", buffer);          
        
          if(n<0)
          {
            perror(buffer);
            fd_gpio[z]=0;
          }
          else
          fd_gpio[z]=n;
        }


    irq=read(fd_gpio[0], rdbuf, RDBUF_LEN-1);
    if(irq<0) 
    {
      perror("read()");
      return 4;
    }
    
    irq=read(fd_gpio[1], rdbuf, RDBUF_LEN-1);
    if(irq<0) 
    {
      perror("read()");
      return 4;
    }
    
    irq=read(fd_gpio[2], rdbuf, RDBUF_LEN-1);
    if(irq<0) 
    {
      perror("read()");
      return 4;
    }

[Dennis H. (c-logic)]

Vom logischen Standpunkt her werden die Filepointer ja auch in das Array 
fd_gpio eingelesen.
Japp genau so

[Welle 🧐 S. (w3llschmidt)]

Irgendwo ist in der Open-Schleife noch ein Wurm ...

Nov 25 16:40:18 rpi s0vz: :/sys/class/gpio/gpio17/value
Nov 25 16:40:18 rpi s0vz: :Bad file descriptor
Nov 25 16:40:18 rpi s0vz: :/sys/class/gpio/gpio18/value
Nov 25 16:40:18 rpi s0vz: :Bad file descriptor
Nov 25 16:40:18 rpi s0vz: :/sys/class/gpio/gpio21/value
Nov 25 16:40:18 rpi s0vz: :Bad file descriptor

%m ist der letzte Return-Code? Dann von: int n=open(buffer,O_RDONLY); ?!

        char gpio[][3] = {"17","18","21"};
        int fd_gpio[3]={0};

        int z;
        for(z=0;z<3;z++)
        {
          char buffer[GPIO_FN_MAXLEN+1];
          snprintf(buffer, GPIO_FN_MAXLEN-1, "/sys/class/gpio/gpio%s/value", gpio[z]);
          syslog(LOG_INFO, ":%s", buffer);
          int n=open(buffer,O_RDONLY);
                
          if(n<0)
          {
            syslog(LOG_INFO, "Error > %m: %s", buffer);
            fd_gpio[z]=0;
          }
          fd_gpio[z]=n;
          syslog(LOG_INFO, ":%m");
        }

[EmbededLinux (Gast)]

sind die GPIO's vorher auch aktiviert worden?
Andernfalls gibt es sie nämlich nicht, d.h. Fehler ist korrekt.

Hier mal auf die Schnelle als Shell-Script:

# Set up GPIO 4 and set to output
echo "4" > /sys/class/gpio/export
echo "out" > /sys/class/gpio/gpio4/direction

# Set up GPIO 7 and set to input
echo "7" > /sys/class/gpio/export
echo "in" > /sys/class/gpio/gpio7/direction

# Write output
echo "1" > /sys/class/gpio/gpio4/value

# Read from input
cat /sys/class/gpio/gpio7/value

# Clean up
echo "4" > /sys/class/gpio/unexport
echo "7" > /sys/class/gpio/unexport

[Welle 🧐 S. (w3llschmidt)]

Klar ;-)

Aber danke für den Tip!

pi@rpi ~ $ ls -la /sys/class/gpio/gpio*
lrwxrwxrwx 1 root root 0 Nov 24 20:17 /sys/class/gpio/gpio17 -> ../../devices/virtual/gpio/gpio17
lrwxrwxrwx 1 root root 0 Nov 24 20:17 /sys/class/gpio/gpio18 -> ../../devices/virtual/gpio/gpio18
lrwxrwxrwx 1 root root 0 Nov 24 20:17 /sys/class/gpio/gpio21 -> ../../devices/virtual/gpio/gpio21
lrwxrwxrwx 1 root root 0 Nov 24 20:17 /sys/class/gpio/gpio22 -> ../../devices/virtual/gpio/gpio22
lrwxrwxrwx 1 root root 0 Nov 24 20:17 /sys/class/gpio/gpio23 -> ../../devices/virtual/gpio/gpio23
lrwxrwxrwx 1 root root 0 Nov 24 20:17 /sys/class/gpio/gpio24 -> ../../devices/virtual/gpio/gpio24
lrwxrwxrwx 1 root root 0 Nov 25 17:35 /sys/class/gpio/gpiochip0 -> ../../devices/virtual/gpio/gpiochip0
pi@rpi ~ $ cat /sys/class/gpio/gpio*/value
1
1
1
0
0
0

Ich überprüfe das hier ->

if (fd_gpio[z] < 0 )
          {
            syslog(LOG_INFO, "Error > %m: %s", buffer);
            fd_gpio[z]=0;
          }

[Dennis H. (c-logic)]

Was bekommste für nen filedescriptor wenn du das von Hand machst ?

Also ein open("/sys/class/gpio/gpio18/value",O_RDONLY) ?

und

if(n<0)
{
 syslog(LOG_INFO, "Error > %m: %s", buffer);
 fd_gpio[z]=0;
}
else
 fd_gpio[z]=n;

sieht eleganter aus.

[Welle 🧐 S. (w3llschmidt)]

:-D

Nov 25 20:03:58 rpi s0vz: VzServer:localhost
Nov 25 20:03:58 rpi s0vz: VzPort:80
Nov 25 20:03:58 rpi s0vz: VzPath:middleware.php
Nov 25 20:03:58 rpi s0vz: :/sys/class/gpio/gpio17/value
Nov 25 20:03:58 rpi s0vz: debug_fp1:2
Nov 25 20:03:58 rpi s0vz: debug_fp2:2
Nov 25 20:03:58 rpi s0vz: :/sys/class/gpio/gpio18/value
Nov 25 20:03:58 rpi s0vz: debug_fp1:3
Nov 25 20:03:58 rpi s0vz: debug_fp2:3
Nov 25 20:03:58 rpi s0vz: :/sys/class/gpio/gpio21/value
Nov 25 20:03:58 rpi s0vz: debug_fp1:4
Nov 25 20:03:58 rpi s0vz: debug_fp2:4
Nov 25 20:03:58 rpi s0vz: debug:2
Nov 25 20:03:58 rpi s0vz: debug:3
Nov 25 20:03:58 rpi s0vz: debug:4

_

        char gpio[][3] = {"17","18","21"};
        int fd_gpio[3]={0};

        for ( z=0; z<3; z++ )
        {
        
          char buffer[GPIO_FN_MAXLEN+1];
          snprintf ( buffer, GPIO_FN_MAXLEN-1, "/sys/class/gpio/gpio%s/value", gpio[z] );
          syslog ( LOG_INFO, ":%s", buffer );
          int n = open ( buffer, O_RDONLY );
              
          if(n<0)
          {
            syslog(LOG_INFO, "Error > %m: %s", buffer);
            fd_gpio[z]=0;
          }
          else
            fd_gpio[z]=n;
            syslog ( LOG_INFO, "debug_fp1:%d", n );
            syslog ( LOG_INFO, "debug_fp2:%d", fd_gpio[z] );
                                 
        }

          syslog ( LOG_INFO, "debug:%d", fd_gpio[0] );
          syslog ( LOG_INFO, "debug:%d", fd_gpio[1] );
          syslog ( LOG_INFO, "debug:%d", fd_gpio[2] );

...

[Dennis H. (c-logic)]

leer sind die fd's ja schonmal nicht.

          if(n<0)
          {
            syslog(LOG_INFO, "Error > %m: %s", buffer);
            fd_gpio[z]=0;
          }
          else
          {
            fd_gpio[z]=n;
            syslog ( LOG_INFO, "debug_fp1:%d", n );
            syslog ( LOG_INFO, "debug_fp2:%d", fd_gpio[z] );
          }

[Welle 🧐 S. (w3llschmidt)]

Danke Dennis für den Input!

Es läuft :-)

    // S0 starts here!
    char buffer[BUF_LEN];
    char vzuuid[36];
    int inputs = 6;
    struct pollfd fds[inputs];
    char gpio_pin_id[][6] = {"17", "18", "21", "22", "23", "24"};
    int i;
    
      for (i=0; i<inputs; i++) 
      {
        char buffer[BUF_LEN];
        snprintf ( buffer, BUF_LEN, "/sys/class/gpio/gpio%s/value", gpio_pin_id[i] );
        
        if((fds[i].fd = open( buffer, O_RDONLY )) ==-1)
        {
          syslog(LOG_INFO,"Error:%s (%m)", buffer);
        }
      }
    
      for (i=0; i<inputs; i++) 
      {
        fds[i].events = POLLPRI;
      }
        
      while(1) 
      {
        int ret = poll(fds, inputs, -1 );
            
          if(ret<0) 
          {
            syslog(LOG_INFO,"Error: poll(fds, inputs, -1 )");
          }
        
        for (i=0; i<inputs; i++) 
        {
          if (fds[i].revents & POLLPRI)
          {
            int in = read(fds[i].fd, buffer, BUF_LEN);
          
            sprintf(vzuuid, "%d", fds[i].fd);
            http_post(vzuuid);
          }
        }
      }

.

[Dennis H. (c-logic)]

noch 'n Tipp

bei

char gpio_pin_id[][6] = {"17", "18", "21", "22", "23", "24"};

steht die 6 nicht für die Anzahl der Einträge.
Es ist ein Wert für die einzelnen Elemente die die Einträge jeweils 
Aufnehmen können.
Für Strings mit maximal 2 Zeichen reichen dann 2 + 1(Nullbyte) chars.

char gpio_pin_id[][3] = {"17", "18", "21", "22", "23", "24"};

wieviele INPUT-Werte du dann hast kann man mit sizeof(gpio_pin_id)/3 
berechnen.
So bleibts etwas variabler.

(sizeof(gpio_pin_id)/3) sollte 6 ergeben.


Also statt

int inputs = 6;
struct pollfd fds[inputs];
char gpio_pin_id[][6] = {"17", "18", "21", "22", "23", "24"};
int i;

dieses

struct pollfd fds[inputs];
char gpio_pin_id[][3] = {"17", "18", "21", "22", "23", "24"};
int inputs = sizeof(gpio_pin_id)/3;
int i;

[Welle 🧐 S. (w3llschmidt)]

Falls das mal einer hier findet :-)

                char gpio_pin_id[][3] = {"17", "18", "21", "22", "23", "24"};
                int inputs = sizeof(gpio_pin_id)/3;
                struct pollfd fds[inputs];
                int i;

Cool :-) Danke !!!

[Dennis H. (c-logic)]

Ohoh , dein

struct pollfd fds[inputs]

hab ich nicht gesehen sorry.

Da spielt der C-Compiler normal nicht mit.

[Welle 🧐 S. (w3llschmidt)]

Was meinstn?

ich habe nur die Reihenfolge geändert?! Weil der gcc hier maulte:

'inputs' nicht definiert ...

struct pollfd fds[inputs];
char gpio_pin_id[][3] = {"17", "18", "21", "22", "23", "24"};
int inputs = sizeof(gpio_pin_id)/3;
int i;

So, gehts! ->

char gpio_pin_id[][3] = {"17", "18", "21", "22", "23", "24"};
int inputs = sizeof(gpio_pin_id)/3;
struct pollfd fds[inputs];
int i;

Meintest Du das?

[Dennis H. (c-logic)]

Ich hab da nur mal eben was gestutzt.
Hatte noch im Hinterkopf, daß Arrays mit Variabler Länge nicht 
generierbar sind. :)

Vergiß es, ich habs ausprobiert. Geht :)

[Welle 🧐 S. (w3llschmidt)]

Klappt alles wunderbar! Je nach Taste haut er schöne HTTP_POSTs raus :-)

127.0.0.1 - - [26/Nov/2012:21:32:57 +0000] "POST /middleware.php/data/3.json HTTP/1.1" 400 284 "-" "s0vz 0.2"
127.0.0.1 - - [26/Nov/2012:21:32:58 +0000] "POST /middleware.php/data/3.json HTTP/1.1" 400 284 "-" "s0vz 0.2"
127.0.0.1 - - [26/Nov/2012:21:32:58 +0000] "POST /middleware.php/data/3.json HTTP/1.1" 400 284 "-" "s0vz 0.2"
127.0.0.1 - - [26/Nov/2012:21:32:58 +0000] "POST /middleware.php/data/3.json HTTP/1.1" 400 284 "-" "s0vz 0.2"



127.0.0.1 - - [26/Nov/2012:21:33:00 +0000] "POST /middleware.php/data/1.json HTTP/1.1" 400 284 "-" "s0vz 0.2"
127.0.0.1 - - [26/Nov/2012:21:33:01 +0000] "POST /middleware.php/data/1.json HTTP/1.1" 400 284 "-" "s0vz 0.2"
127.0.0.1 - - [26/Nov/2012:21:33:01 +0000] "POST /middleware.php/data/1.json HTTP/1.1" 400 284 "-" "s0vz 0.2"
127.0.0.1 - - [26/Nov/2012:21:33:01 +0000] "POST /middleware.php/data/1.json HTTP/1.1" 400 284 "-" "s0vz 0.2"
127.0.0.1 - - [26/Nov/2012:21:33:01 +0000] "POST /middleware.php/data/1.json HTTP/1.1" 400 284 "-" "s0vz 0.2"



127.0.0.1 - - [26/Nov/2012:21:33:05 +0000] "POST /middleware.php/data/2.json HTTP/1.1" 400 284 "-" "s0vz 0.2"
127.0.0.1 - - [26/Nov/2012:21:33:06 +0000] "POST /middleware.php/data/2.json HTTP/1.1" 400 284 "-" "s0vz 0.2"
127.0.0.1 - - [26/Nov/2012:21:33:06 +0000] "POST /middleware.php/data/2.json HTTP/1.1" 400 284 "-" "s0vz 0.2"
127.0.0.1 - - [26/Nov/2012:21:33:06 +0000] "POST /middleware.php/data/2.json HTTP/1.1" 400 284 "-" "s0vz 0.2"
127.0.0.1 - - [26/Nov/2012:21:33:06 +0000] "POST /middleware.php/data/2.json HTTP/1.1" 400 284 "-" "s0vz 0.2"

[Dennis H. (c-logic)]

Dann ist ja alles bestens :)

[Simon B. (nomis)]

Dennis Heynlein schrieb:
> char gpio_pin_id[][6] = {"17", "18", "21", "22", "23", "24"};

warum nicht

char gpio_pin_id[] = { 17, 18, 21, 22, 23, 24 };

und dann "%d" im Format-String?

Grüße,
        Simon

[Welle 🧐 S. (w3llschmidt)]

Hi Simon,

ich glaube, snprintf() kann nur 'char', kein 'int' ...

[Welle 🧐 S. (w3llschmidt)]

Compilieren geht, aber nach zwei durchläufen steht das Programm ...

Nov 26 21:50:51 rpi s0vz: /sys/class/gpio/gpio17/value
Nov 26 21:50:51 rpi s0vz: /sys/class/gpio/gpio18/value

    // S0 starts here!
    char buffer[BUF_LEN];
    char vzuuid[36];
    //char gpio_pin_id[][3] = {"17", "18", "21", "22", "23", "24"};
    char gpio_pin_id[] = { 17, 18, 21, 22, 23, 24 };
    int inputs = sizeof(gpio_pin_id)/3;
                struct pollfd fds[inputs];
    int i;
    
      for (i=0; i<inputs; i++) 
      {
        char buffer[BUF_LEN];
        //snprintf ( buffer, BUF_LEN, "/sys/class/gpio/gpio%s/value", gpio_pin_id[i] );
        snprintf ( buffer, BUF_LEN, "/sys/class/gpio/gpio%d/value", gpio_pin_id[i] );
  
        syslog(LOG_INFO,"%s", buffer);
        
        if((fds[i].fd = open( buffer, O_RDONLY )) ==-1)
        {
          syslog(LOG_INFO,"Error:%s (%m)", buffer);
        }
      }

[Simon B. (nomis)]

Henrik Wellschmidt schrieb:
> ich glaube, snprintf() kann nur 'char', kein 'int' ...

Also, "%d" kann snprintf definitiv.

Und - gerade ausprobiert - das funktioniert auch, wenn man dem als 
Argument ein char verfüttert...

Grüße,
        Simon

[Welle 🧐 S. (w3llschmidt)]

Simon Budig schrieb:
> Henrik Wellschmidt schrieb:
>> ich glaube, snprintf() kann nur 'char', kein 'int' ...
>
> Also, "%d" kann snprintf definitiv.
>
> Und - gerade ausprobiert - das funktioniert auch, wenn man dem als
> Argument ein char verfüttert...

Check!

Aber die Routine läuft nicht mehr durch ... hmm

[Simon B. (nomis)]

Henrik Wellschmidt schrieb:
> Compilieren geht, aber nach zwei durchläufen steht das Programm ...
>
> Nov 26 21:50:51 rpi s0vz: /sys/class/gpio/gpio17/value
> Nov 26 21:50:51 rpi s0vz: /sys/class/gpio/gpio18/value

Heh, klar   :)

Ich empfehle:

  int inputs = sizeof(gpio_pin_id)/sizeof(gpio_pin_id[0]);

Viele Grüße,
        Simon

[Welle 🧐 S. (w3llschmidt)]

Ok, gekauft ... :-D

    //char gpio_pin_id[][3] = {"17", "18", "21", "22", "23", "24"};
    // 13 Chars weniger!
    char gpio_pin_id[] = { 17, 18, 21, 22, 23, 24 };
    
    //int inputs = sizeof(gpio_pin_id)/3;
    //int inputs = sizeof(gpio_pin_id)/sizeof(gpio_pin_id[0]);
    // 11 Chars mehr!
    int inputs = sizeof(gpio_pin_id)/sizeof(char);

[Welle 🧐 S. (w3llschmidt)]

Hää, wo issn der Post von Dennis ?

[Welle 🧐 S. (w3llschmidt)]

Simon, schau mal -> 8 Zeichen mehr :-)

    //char gpio_pin_id[][3] = {"17", "18", "21", "22", "23", "24"};
    // 13 Chars weniger!
    char gpio_pin_id[] = { 17, 18, 21, 22, 23, 24 };
    
    //int inputs = sizeof(gpio_pin_id)/3;
    //  21 Chars mehr!
    int inputs = sizeof(gpio_pin_id)/sizeof(gpio_pin_id[0]);

[Simon B. (nomis)]

Henrik Wellschmidt schrieb:
> Ok, gekauft ... :-D

Fein.  :)

Noch ein Hinweis:

  // 13 Chars weniger!
  // 11 Chars mehr!

Ich kriege gerade Angst, dass Du hier die Größe des Sourcecode-Texts 
misst. Wofür?

Als Qualitätsmerkmal taugt das nicht - eher im Gegenteil: Mehr Text 
bedeutet meist auch bessere Lesbarkeit. Wenn dann wäre eher interessant 
wieviel RAM zur Laufzeit verbraucht wird. Aber das wäre im Moment noch 
viel zu früh um sich darüber Gedanken zu machen...

Ansonsten:

char i,b[BUF_LEN];char gpid[]={17,18,21,22,23,24};
struct pollfd fds[6];
for(i=0;i<6;i++){
snprintf(b,BUF_LEN,"/sys/class/gpio/gpio%d/value",gpid[i]);
syslog(LOG_INFO,"%s",b);
if((fds[i].fd=open(b,O_RDONLY))<0){
syslog(LOG_INFO,"Error:%s (%m)",b);}}

Viele Grüße,
        Simon

[Simon B. (nomis)]

Henrik Wellschmidt schrieb:
> Simon, schau mal -> 8 Zeichen mehr :-)

Bitte meine das als Witz   :-)

Grüße,
        Simon

[Dennis H. (c-logic)]

>>> Hää, wo issn der Post von Dennis ?

Ich lösch ja manchmal Beiträge, wenn ich Quark geschrieben hab oder 
jemand mit der Antwort schneller ist :)

[Welle 🧐 S. (w3llschmidt)]

Simon Budig schrieb:
> Henrik Wellschmidt schrieb:
>> Simon, schau mal -> 8 Zeichen mehr :-)
>
> Bitte meine das als Witz   :-)
>
> Grüße,
>         Simon


Ok, ich meinte das als Witz ;-)

Zumindest im nachhinein :-D