Umwandlung von 8bit zu 7bit

[chris_1981_]

Hallo mfro,

danke für den Tipp, ich bin ja doch ein wenig erleichtert über die *FILE Open Situation. Hehe, einfach reicht mir erst einmal.
Wenn ich aber nun die Baudrate einstellen will, muss ich vorher stty aufrufen per Systems-Befehl und die Baudrate und die Partiy und die Stoppbits definieren?

Vielleicht ein kleiner Überblick nicht das noch jemand auf die Idee kommt, das jetzige Programm, würde ich eins zu eins auf einen Mikrocontroller laufen lassen:
Das jetzige C-Programm soll mit dem Mikrocontroller kommunizieren, das heißt der Mikrocontroller soll später direkt die Ladung des Handys + die Events des Handys, das heißt den PDU-String übersetzen und gegebenenfalls andere Meldungen wie Temparatur der Räume, Lichtstärke und vieles, vieles mehr über die UART Schnittstelle an ein CUBIEBOARD senden, diese Informationen werden dann in eine MySQL Datenbank gespeichert. Zusätzlich wird an den Mikrocontroller ein Event ausgelöst, aufgrund einer Meldung / Berechnung / Steuerung. == beidseitige Kommunikation.
Klar, geht das einfacher, aber einfach kann jeder und wo bleibt die Fantasie und Spaß bei der Sache. Schließlich will ich auch noch ne Menge lernen.

Für den Mikrocontroller ala 'Atmel', habe ich schon etwas fertiges für die UART Kommunikation, dass ich hier neuschreiben musste war mir klar und wird wieder ein ganzes Stück mehr arbeit werden wenn ich mal auf die ARM Serie umsteigen will / muss. ( 8Bit -> 32Bit ).

[mfro]

Wenn ich aber nun die Baudrate einstellen will, muss ich vorher stty aufrufen per Systems-Befehl und die Baudrate und die Partiy und die Stoppbits definieren?

In meinem Link steht nichts von stty .

Trotzdem geht's damit. Allerdings muß das Device dazu geöffnet sein (sonst wird die Baudrate zwar durch stty umgestellt, fällt aber sofort nach dem Schließen - wenn das stty-Kommando beendet wird - wieder auf den Default zurück).

[chris_1981_]

ok, sorry, ich sollte auch mal deine Texte nach dem lesen, auch verstehen.
ich antworte mal, wenn ich es hinbekommen habe.

Danke!

[cloidnerux]

Für den Mikrocontroller ala 'Atmel', habe ich schon etwas fertiges für die UART Kommunikation, dass ich hier neuschreiben musste war mir klar und wird wieder ein ganzes Stück mehr arbeit werden wenn ich mal auf die ARM Serie umsteigen will / muss. ( 8Bit -> 32Bit ).

Die Meisten Mikrocontroller/Mikroprozessoren haben Hardware-UART Module, so auch die Atmel AVRs oder die STM32(Basierend auf ARM Cortex-M3). Du setzt die passenden Register und das wars. Für den AVR sind das 2-3 Zeilen Code, für nen STM32 ein paar mehr. Aber wirklich umständlich ist das nur auf dem Computer.

[chris_1981_]

hallo mfro,

ich hatte gedacht, mit den vorherigen Code hätte ich schon diesen Weg eingeschlagen.(?)
Ich habe das Beispiel von dem Link einfach genommen und versuche nun eine Kommunikation aufzubauen.

Code: Alles auswählen

int main (int argc, char **argv)
{
    int fd; /* File descriptor for the port */
    struct termios options;

    int n=0;
    fd = open(MODEDEVICE, O_RDWR | O_NOCTTY | O_NDELAY);
    fcntl(fd, F_SETFL, 0);

    /*
     * Get the current options for the port...
     */
    tcgetattr(fd, &options);

    /*
     * Set the baud rates to 19200...
     */
    cfsetispeed(&options, B19200);
    cfsetospeed(&options, B19200);

    options.c_cflag &= ~PARENB;
    options.c_cflag &= ~CSTOPB;
    options.c_cflag &= ~CSIZE;
    options.c_cflag |= CS8;
    //options.c_cflag &= ~CNEW_RTSCTS;

    /* set the options */
    tcsetattr(fd, TCSANOW, &options);

    if (fd == -1)
    {
        /*
         * Could not open the port.
         */
        perror("open_port: Unable to open /dev/ttyUSB0 - ");
    }
    else
    {
        fcntl(fd, F_SETFL, 0);
    }

    while(1)
    {
        n = write(fd, "at^SRTC=0\r", 10);
        if (n < 0)
        {
            fputs("write() of 4 bytes failed!\n", stderr);
        }
        else
        {
            printf("yes all is fine\n");
        }

    }
return 0;
}

Hast du einen Rat für mich?

[chris_1981_]

Die Meisten Mikrocontroller/Mikroprozessoren haben Hardware-UART Module, so auch die Atmel AVRs oder die STM32(Basierend auf ARM Cortex-M3). Du setzt die passenden Register und das wars. Für den AVR sind das 2-3 Zeilen Code, für nen STM32 ein paar mehr. Aber wirklich umständlich ist das nur auf dem Computer.

Japp, das stimmt, mit Interrupt sind es ein paar mehr Zeilen.
Der Code für UART auf einem Atmega 8 oder 168, 328, 32, 128, ........ 2560 usw. ist fertig, Anpassung aufgrund der unterschiedlichsten Modelle sind zwar notwendig, aber der Code, wenn man überhaupt von Code sprechen kann ist fertig. Bin mal gespannt, wann es soweit ist, wenn man keinen 8-Bit`ter mehr kaufen kann und man gezwungen ist umzusteigen. Sorry für den "off-topic".

[mfro]

Hast du einen Rat für mich?

Klar, hast Du ein Problem für mich?

Das sieht doch schon mal gar nicht schlecht aus!

[chris_1981_]

es sieht fast so aus als würden die Daten nicht übertragen werden,... ich prüfe das noch einmal bzw. die Optionen.

Ich mag gar nicht fragen, wie lese ich denn nun aus?
Die while -Schleife habe ich schon einmal, jetzt muss ich wahrscheinlich "bitweise" auslesen?
Und was ist nun der Unterschied zum vorherigen Code?

Code: Alles auswählen

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

        /* baudrate settings are defined in <asm/termbits.h>, which is
        included by <termios.h> */
        #define BAUDRATE B19200            
        /* change this definition for the correct port */
        #define MODEMDEVICE "/dev/ttyUSB0"
        #define _POSIX_SOURCE 1 /* POSIX compliant source */

        #define FALSE 0
        #define TRUE 1

        volatile int STOP=FALSE; 

        main()
        {
          int fd,c, res;
          struct termios oldtio,newtio;
          char buf[255];
        /* 
          Open modem device for reading and writing and not as controlling tty
          because we don't want to get killed if linenoise sends CTRL-C.
        */
         fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY ); 
         if (fd <0) {perror(MODEMDEVICE); exit(-1); }
        
         tcgetattr(fd,&oldtio); /* save current serial port settings */
         bzero(&newtio, sizeof(newtio)); /* clear struct for new port settings */
        
        /* 
          BAUDRATE: Set bps rate. You could also use cfsetispeed and cfsetospeed.
          CRTSCTS : output hardware flow control (only used if the cable has
                    all necessary lines. See sect. 7 of Serial-HOWTO)
          CS8     : 8n1 (8bit,no parity,1 stopbit)
          CLOCAL  : local connection, no modem contol
          CREAD   : enable receiving characters
        */
         newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
         
        /*
          IGNPAR  : ignore bytes with parity errors
          ICRNL   : map CR to NL (otherwise a CR input on the other computer
                    will not terminate input)
          otherwise make device raw (no other input processing)
        */
         newtio.c_iflag = IGNPAR | ICRNL;
         
        /*
         Raw output.
        */
         newtio.c_oflag = 0;
         
        /*
          ICANON  : enable canonical input
          disable all echo functionality, and don't send signals to calling program
        */
         newtio.c_lflag = ICANON;
         
        /* 
          initialize all control characters 
          default values can be found in /usr/include/termios.h, and are given
          in the comments, but we don't need them here
        */
         newtio.c_cc[VINTR]    = 0;     /* Ctrl-c */ 
         newtio.c_cc[VQUIT]    = 0;     /* Ctrl-\ */
         newtio.c_cc[VERASE]   = 0;     /* del */
         newtio.c_cc[VKILL]    = 0;     /* @ */
         newtio.c_cc[VEOF]     = 4;     /* Ctrl-d */
         newtio.c_cc[VTIME]    = 0;     /* inter-character timer unused */
         newtio.c_cc[VMIN]     = 1;     /* blocking read until 1 character arrives */
         newtio.c_cc[VSWTC]    = 0;     /* '\0' */
         newtio.c_cc[VSTART]   = 0;     /* Ctrl-q */ 
         newtio.c_cc[VSTOP]    = 0;     /* Ctrl-s */
         newtio.c_cc[VSUSP]    = 0;     /* Ctrl-z */
         newtio.c_cc[VEOL]     = 0;     /* '\0' */
         newtio.c_cc[VREPRINT] = 0;     /* Ctrl-r */
         newtio.c_cc[VDISCARD] = 0;     /* Ctrl-u */
         newtio.c_cc[VWERASE]  = 0;     /* Ctrl-w */
         newtio.c_cc[VLNEXT]   = 0;     /* Ctrl-v */
         newtio.c_cc[VEOL2]    = 0;     /* '\0' */
        
        /* 
          now clean the modem line and activate the settings for the port
        */
         tcflush(fd, TCIFLUSH);
         tcsetattr(fd,TCSANOW,&newtio);
        
        /*
          terminal settings done, now handle input
          In this example, inputting a 'z' at the beginning of a line will 
          exit the program.
        */
         while (STOP==FALSE) {     /* loop until we have a terminating condition */
         /* read blocks program execution until a line terminating character is 
            input, even if more than 255 chars are input. If the number
            of characters read is smaller than the number of chars available,
            subsequent reads will return the remaining chars. res will be set
            to the actual number of characters actually read */
            res = read(fd,buf,255); 
            buf[res]=0;             /* set end of string, so we can printf */
            printf(":%s:%d\n", buf, res);
            if (buf[0]=='z') STOP=TRUE;
         }
         /* restore the old port settings */
         tcsetattr(fd,TCSANOW,&oldtio);
        }

Bei diesem Code habe ich auch einen open & read Befehl genutzt.
Entschuldigt die dummen Fragen.

[mfro]

Ich mag gar nicht fragen, wie lese ich denn nun aus?
Die while -Schleife habe ich schon einmal, jetzt muss ich wahrscheinlich "bitweise" auslesen?
Und was ist nun der Unterschied zum vorherigen Code?

read(int fildes, void *buf, size_t nbyte) liest Bytes vom Dateideskriptor fildes. Und zwar so lange, bis nbyte Bytes gelesen sind.

Zumindest für den "ersten Wurf" sollte nbyte also sinnvollerweise 1 sein, um zeichenweise zu lesen (sonst kannst Du das Ende nicht erkennen).

[chris_1981_]

Hallo mfro,

sorry für die Rückfrage,

aber wo liegt nun der Unterschied zwischen den beiden Codevarianten?
Warum erwidert mein Handy erst den at befehl, wenn ich minicom dazugeschaltet habe?