Umwandlung von 8bit zu 7bit

[chris_1981_]

Hallo mfro,

Fehler gefunden:

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


Der markierte Eintrag war Schuld.

[mfro]

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?

Vielleicht hab' ich ja nicht richtig geguckt, aber in einem Programm schreibst Du einen AT-Befehl ans Handy, liest aber nichts zurück. Im anderen liest Du, hast aber vorher nichts geschrieben (dann kann ja auch keine Antwort kommen).

Wenn Du die beiden Programme jetzt noch _richtig_ verheiratest, so daß das Frage/Antwort richtig zusammenspielt, müsstest Du der Sache schon deutlich näher kommen.

[chris_1981_]

hallo mfro,

ja ok, das Frage / Antwort -Spiel scheint aktuell besser zu werden.
Ich muss halt noch herauszufinden wie ich es schaffe, dass das Handy bevor ich einen 2. Befehl sende ein OK oder ein Error dazwischen bekommt, ich habe gerade so einige Ideen im Kopf, Continue und Break und so weiter, mal sehen, es darf halt nichts blockieren.

[chris_1981_]

hallo mfro,

nutzt du bei deinen Programmen folgende Option?

Code: Alles auswählen

options.c_lflag |= (ICANON );

Canonical input is line-oriented. Input characters are put into a buffer which can be edited interactively by the user until a CR

Ich habe diese Option, warum auch immer ich diese vorher deaktiviert habe, aktiviert "|=" und somit bekomme ich immer wieder mein "Line-Data" so wie ich es haben möchte.
Im deaktivierten Zustand, wird es schwer die Zeichen aneinander zu bekommen...
Liege ich mit der Vermutung / Zustand richtig?

[mfro]

hallo mfro,

nutzt du bei deinen Programmen folgende Option?

Code: Alles auswählen

options.c_lflag |= (ICANON );

Canonical input is line-oriented. Input characters are put into a buffer which can be edited interactively by the user until a CR

Ich habe diese Option, warum auch immer ich diese vorher deaktiviert habe, aktiviert "|=" und somit bekomme ich immer wieder mein "Line-Data" so wie ich es haben möchte.
Im deaktivierten Zustand, wird es schwer die Zeichen aneinander zu bekommen...
Liege ich mit der Vermutung / Zustand richtig?

Das kann man schon so machen. read() kehrt dann erst zurück, wenn eine ganze Zeile eingelesen ist, allerdings schaltet ICANON dann auch den Edit-Modus ein, der auf Steuerzeichen reagiert - die kannst Du dann nicht mehr empfangen.

Ich glaube, jetzt müssen wir mal aufpassen, daß Du nicht allzusehr vom Weg abkommst.

Mal überlegen, wo Du eigentlich hin willst.

Das soll nachher auf einem Microcontroller laufen, da hast Du auch keine Funktion, um eine ganze Zeile einzulesen.

Ich kenne die Hardware nicht, aber wahrscheinlich sieht sie so aus, daß Du ein UART-Register hast, das ein Flag gesetzt bekommt, sobald ein Zeichen empfangsbereit im FIFO steht und ein anderes Flag, das aktiv wird, sobald ein Zeichen komplett übertragen (gesendet) wurde. Abhängig von diesen beiden Flags schreibst oder liest Du ein Byte in/aus ein oder mehreren anderen UART-Registern, richtig?

Das wird dann wahrscheinlich irgendwie so aussehen:

Code: Alles auswählen

bool ende_bedingung = false;
while (! ende_bedingung)
{
    if (empfaenger_hat_ein_zeichen())
    {
        empfange_zeichen();
    }
    if (sender_bereit() && bytes_zu_senden())
    {
        sende_zeichen();
    }
}

}

So würde man normalerweise nie ein Programm für ein Betriebssystem schreiben (da würde man auf die Finger gehauen bekommen, weil der Prozessor in der Schleife ohne was zu tun ohne Ende Prozessorzyklen verbrät), aber einen Mikrocontroller programmiert man eben so, falls man die Zeichen nicht interruptgesteuert senden und empfangen will.

Jetzt kommt's drauf an, die Betriebssystem-Äquivalente für die entsprechende (noch theoretischen) UART-Funktionalität zu finden:

Code: Alles auswählen

sender_bereit()                               /* das Senderegister ist leer */
empfaenger_hat_ein_zeichen()        /* das Empfangsregister ist bereit zum Auslesen */
empfange_zeichen()
sende_zeichen()         

Bist Du noch bei mir und liege ich halbwegs richtig?

[chris_1981_]

Hallo mfro,

ok, vielleicht anders gesagt, ich will ja grundsätzlich C lernen, das heißt für mich, der Mikrocontroller steht erst einmal hinten an.
Wenn ich C ein bisschen besser verstehe, mache ich mich an das Programmieren des Mikrocontrollers, wobei ich hier schon einiges an "wirklich einfachen" Dingen fertig habe.
Würfel, SoftPWM für ein Licht mit 5M LED Strip, Uhr mit Licht, usw., viele dieser Projekte waren in Büchern angefangen und ich habe es mit "einfachen" Sachen erweitert Schalte etc.
Jetzt sollen andere Projekte dran glauben, dazu muss ich aber ein absolut besseres Verständnis für C haben.

Diese Funktion der Schnittstellen Kommunikation soll später auch in Verbindung "Mikrocontroller <----> Cubieboard" funktionieren, daher ist die aktuelle Entwicklung nicht für die Katz.
Klar kann ich bei diesem Cubieboard, ein ähnlicher Rasperry PI, wobei mit ordentlich mehr Dampf, unter Python oder Perl schreiben, das läuft aktuell sogar schon, aber es soll auch hier in C sein, der ständige Wechsel von dieser Sprache zu jener nervt.

Jetzt aber zurück.

Ich kenne die Hardware nicht, aber wahrscheinlich sieht sie so aus, daß Du ein UART-Register hast, das ein Flag gesetzt bekommt, sobald ein Zeichen empfangsbereit im FIFO steht und ein anderes Flag, das aktiv wird, sobald ein Zeichen komplett übertragen (gesendet) wurde. Abhängig von diesen beiden Flags schreibst oder liest Du ein Byte in/aus ein oder mehreren anderen UART-Registern, richtig?

Ja.

<der angesprochene Code>
So würde man normalerweise nie ein Programm für ein Betriebssystem schreiben (da würde man auf die Finger gehauen bekommen, weil der Prozessor in der Schleife ohne was zu tun ohne Ende Prozessorzyklen verbrät), aber einen Mikrocontroller programmiert man eben so, falls man die Zeichen nicht interruptgesteuert senden und empfangen will.

Das sollte man besser über Interrupts machen vor allem wenn der µC hier und da noch andere Dinge tun will.
Also ist die Art auch beim µC nicht wirklich vorteilhaft.

Bist Du noch bei mir und liege ich halbwegs richtig?

Ja und nicht nur halbwegs.
Um es in Worten auszudrucken:
Aktuell möchte ich mit C eine Kommunikation hinbekommen, damit ich auch von meinem Cubieboard (PC) zum µC und zurück kommunizieren kann.

[mfro]

Ja und nicht nur halbwegs.

Prima. Dann kriegst Du jetzt eine Hausaufgabe . Nachlesen, wie wir die folgenden Funktionen für POSIX-Systeme bauen können:

Code: Alles auswählen

sender_bereit()                               /* das Senderegister ist leer */
empfaenger_hat_ein_zeichen()        /* das Empfangsregister ist bereit zum Auslesen */
empfange_zeichen()
sende_zeichen()

Lies' über

Code: Alles auswählen

ioctl(fd, FIONREAD, &nbytes)
read(fd, ...)
write(fd, ...)

Soviel Du finden kannst. "sender_bereit()" ist bei POSIX-Funktionen nicht notwendig, und das kryptische ioctl() sagt dir, wieviele Bytes Du mit read() lesen kannst, ohne daß der Aufruf blockiert. Abgesehen von dem Code, den Du schon hast (um die serielle Schnittstelle zu konfigurieren) brauchst Du (wahrscheinlich) nur diese drei Funktionen.

[chris_1981_]

Cool, endlich mal Jemand der auch noch an diesen Dingen Spaß hat
Danke, ich werde die Hausaufgaben aber nicht zu morgen erledigen können .

Ich melde mich der Tipp mit ioctl(fd, FIONREAD, &nbytes), birngt mit schon einmal weiter.

PS: wir reden aber immer noch vom C auf dem PC und nicht vom µC?

Vielen Dank!

[mfro]

PS: wir reden aber immer noch vom C auf dem PC und nicht vom µC?

Klar. Wir müssen die "busy waiting"-Variante nehmen, also "Schleifen drehen", bis ein Zeichen bereit steht, sonst müssten wir ein nebenläufiges (multi-threaded) Programm schreiben und das ist dann wohl doch "too heavy" für den Anfang.

[chris_1981_]

sonst müssten wir ein nebenläufiges (multi-threaded) Programm schreiben und das ist dann wohl doch "too heavy" für den Anfang.

Jepp, verstanden und auch klar.


erste Versuche...

Code: Alles auswählen

#include <stdio.h>   /* Standard input/output definitions */
#include <string.h>  /* String function definitions */
#include <unistd.h>  /* UNIX standard function definitions */
#include <fcntl.h>   /* File control definitions */
#include <errno.h>   /* Error number definitions */
#include <termios.h> /* POSIX terminal control definitions */

#define BAUDRATE        19200
#define MODEMDEVICE     "/dev/ttyUSB0"

#define FALSE 0
#define TRUE 1

/*
 * 'open_port()' - Open serial port 1.
 *
 * Returns the file descriptor on success or -1 on error.
 */
int open_port(void)
{
    int fd; /* File descriptor for the port */

    struct termios options;

    fd = open(MODEMDEVICE, 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_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
    options.c_cflag &= ~CRTSCTS;

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

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


char *read_bytes ( char *string, char *string_return )
{






}


int *write_bytes ( int fd, char *string )
{
    int n = 0;

    // !!!! FIXME !!!!
    // sizeof parameter 
    // with chars? or better 
    // count the chars?

    n = write(fd, string, 9);
    if (n < 0)
    {
        fputs("write() of 9 bytes failed!\n", stderr);
        return 1;
    }
    else
    {
        return 0;
    }
}

int main (int argc, char **argv)
{
    int fd,c, res;
    char buf[255];
    struct termios options;
    int n=0;
    int i=0;
    int bytes;
    int port = 0;

    char check_handy_con[] = "at\r\n"; // ok
    char start_modem[] = "at???"; // we need the step
    char reset_modem[] = "atz0\r\n"; // OK -> after this do initialisize 
    char enable_clip[] = "at+clip=1\r\n"; // ok
    char disable_local_echo[] = "ate0\r\n"; // ok
    char disable_vibration[] = "at+cvib=0\r\n"; // ok
    char battery_status[] = "at+cbc\r\n"; // +CBC: 0,100
    char read_manufacter[] = "at+cgmi\r\n"; // SIEMENS
    char read_sms_new[] = "at+cmgl=\r\n";// new message or ok
    char read_funk_quality[] = "at+csq\r\n"; // +CSQ: 19,99
    char info_sms_inc[] = "at+cnmi=1,1\r\n"; // ok # +CMTI: "SM",x
    char delete_sms_ind[] = "at+cmgd=1\r\n"; // ok 
    char disable_ringtone[] ="at^SRTC=0\r\n"; // ok

    port = open_port();
    printf ("openport == %i\n", port);
    
    // FIXME 
    // if statement open port

    // FIXME
    // while loop for reading serial?

     // FIXME
    // ioctl(fd, FIONREAD, &bytes);

    while ( 

    close(fd);
    return 0;
}

>>> nicht getestet nicht übersetzt erst einmal auf geschrieben, der Rest kommt bzw. es wird noch korrigiert.