Seriel kommunikation i linux

Måske kan du få et par ideer her:

http://www.eksperten.dk/spm/664872

Jeg blev da lidt inspireret, de eksempler som der blev vist på siden, kunne da også compileres, Men når jeg kører filen, kommer der en masse error output.
feks:
./serial: line 22: typedef: command not found
./serial: line 23: typedef: command not found
./serial: line 24: typedef: command not found
./serial: line 27: struct: command not found
./serial: line 29: tcflag_t: command not found
./serial: line 30: tcflag_t: command not found
./serial: line 31: tcflag_t: command not found
./serial: line 32: tcflag_t: command not found

Lidt frusterende, men igen.. jeg tror det er fordi det er en mipsel arkitektur.

Det er ikke lige det output jeg ville forvente af programmet.
Er du sikker på at det er oversat rigtigt? Hvordan har du oversat?
Hvordan ser koden ud?

Jeg har oversat det med mipsel-linux-gnu-cpp serial4.c -o serial

som sagt er jeg ikke den store kodehaj, men ville da have troet, at hvis den ikke meldte nogen fejl, ville programmet virker (mere eller mindre)

sådan ser koden ud

      #include <termios.h>
      #include <stdio.h>
      #include <unistd.h>
      #include <fcntl.h>
      #include <sys/signal.h>
      #include <sys/types.h>

      #define BAUDRATE B38400
      #define MODEMDEVICE "/dev/ttyS1"
      #define _POSIX_SOURCE 1 /* POSIX compliant source */
      #define FALSE 0
      #define TRUE 1

      volatile int STOP=FALSE;

      void signal_handler_IO (int status);  /* definition of signal handler */
      int wait_flag=TRUE;                    /* TRUE while no signal received */

      main()
      {
        int fd,c, res;
        struct termios oldtio,newtio;
        struct sigaction saio;          /* definition of signal action */
        char buf[255];

        /* open the device to be non-blocking (read will return immediatly) */
        fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY | O_NONBLOCK);
        if (fd <0) {perror(MODEMDEVICE); exit(-1); }

        /* install the signal handler before making the device asynchronous */
        saio.sa_handler = signal_handler_IO;
        saio.sa_mask = 0;
        saio.sa_flags = 0;
        saio.sa_restorer = NULL;
        sigaction(SIGIO,&saio,NULL);

        /* allow the process to receive SIGIO */
        fcntl(fd, F_SETOWN, getpid());
        /* Make the file descriptor asynchronous (the manual page says only
          O_APPEND and O_NONBLOCK, will work with F_SETFL...) */
        fcntl(fd, F_SETFL, FASYNC);

        tcgetattr(fd,&oldtio); /* save current port settings */
        /* set new port settings for canonical input processing */
        newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
        newtio.c_iflag = IGNPAR | ICRNL;
        newtio.c_oflag = 0;
        newtio.c_lflag = ICANON;
        newtio.c_cc[VMIN]=1;
        newtio.c_cc[VTIME]=0;
        tcflush(fd, TCIFLUSH);
        tcsetattr(fd,TCSANOW,&newtio);

        /* loop while waiting for input. normally we would do something
          useful here */
        while (STOP==FALSE) {
          printf(".\n");usleep(100000);
          /* after receiving SIGIO, wait_flag = FALSE, input is available
            and can be read */
          if (wait_flag==FALSE) {
            res = read(fd,buf,255);
            buf[res]=0;
            printf(":%s:%d\n", buf, res);
            if (res==1) STOP=TRUE; /* stop loop if only a CR was input */
            wait_flag = TRUE;      /* wait for new input */
          }
        }
        /* restore old port settings */
        tcsetattr(fd,TCSANOW,&oldtio);
      }

      /***************************************************************************
      * signal handler. sets wait_flag to FALSE, to indicate above loop that    *
      * characters have been received.                                          *
      ***************************************************************************/

      void signal_handler_IO (int status)
      {
        printf("received SIGIO signal.\n");
        wait_flag = FALSE;
      }

Det blev jeg vist ikke ret meget klogere af...

Jeg skal lige forstå jeres opsætning; I har en microcontroller (80c535) som skal sende til en ombygget router? Routeren skal så opfange dette og gemme i en fil, dvs. routeren har et filsystem og en com-port?

Når du compilerer koden gør du det så på routeren? Eller?
Hvor forsøger du at afvikle programmet?

i routeren (en ombygget asus WL-500g) er der 2 USB-porte, den ene sidder den en disk til, hvor selve linux(debian) ligger på, den anden usb port, sidder der en usb -> serial converter.
Vi har prøvet med de indbyggede programmer i debian, at modtage noget igennem den serielle port, så hardware mæssigt fejler den ikke noget.

jeg compiler hele koden på routeren ja, og forsøger også at afvikle det derpå :-)

Ok.

Jeg tror dog stadig at der er noget galt med oversættelsen (compileringen).
Noget siger mig at den ikke får lavet et rigtigt program og bliver forvirret når du forsøger at køre dette "ikke rigtige program"

Kan du lave andre programmer der virker?

Jeg kan da lave en normal "hello world" men det er også det eneste jeg har prøvet

Hvordan ser sourcen til "hello world" programmet ud og hvordan oversætter du det?

Den ser således ud :

/*----------------------------------------------------
* eCos 'Hello world' example
* --------------------------------------------------*/


#include <stdio.h>
//#include "library_example.h"


int main(int argc, char* argv[])
{
    int i;



    for (i=0; i<10; i++)
    {
      printf("Hello world!\n\r");
    }
    return 0;
}


mipsel-linux-gnu-gcc hello.c -o hello
chmod 777 hello
./hello
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!

Tja, det ser jo ok ud.

Du kunne prøve at putte små bidder fra serial4.c over i hello.c, compiler og køre og så se hvad der sker.

Får du ikke nogle beskeder fra compileren når du oversætter serial4.c?

Jeg har fået det til at virke nu :-)
Efter et par hjernevridende dage, kom der hul igennem.