Lighttpd + UART - Wird nichts gesendet

[Kampi]

Ok es funktioniert in der Originalversion.
Dann habe ich wohl unbeabsichtigt was falsch gemacht als ich ein paar Sachen angepasst habe.

Edit: Banaler Fehler.....hab im Dateipfad von der PHP Datei das /www vergessen.....

[peterfido]

Schön , dann kann es ja jetzt weiter gehen..

[Kampi]

Ja mal schauen was sich damit machen lässt
Wenn ich was über den UART senden möchte brauch ich root-Rechte?
Wenn mir die Datei dann im FileZilla mit root und www-data als Besitzer angezeigt wird sollte das ja dann klappen wenn ich root-Rechte benötige oder?

[peterfido]

Mit sudo klappt das senden per UART. Wichtig ist halt, die Kennwortabfrage per visudo für das Senden Programm abzuschalten, wie weiter oben beschrieben.
Auf meinem ersten Raspi ging es auch ohne sudo. Allerdings habe ich da vorher viel hin und her (de)installiert und probiert...

[Kampi]

Juhu es klappt
Hab dein Programm bischen umgemodelt und nun wird jedesmal ein Text gesendet wenn ich im WebIf den Button drücke.
Waren zwar ein paar ein paar Fallstricke dabei (z.B. if (argc >= 1) habe ich auf if (argc == 1) stehen gelassen und mich gewundert warum es nicht klappt )
Ist dieser Teil hier:

int init()                                                                                                //Schnittstelle öffnen und parametrieren
{
    /*** Init ***/
    
    //O_RDONLY, O_WRONLY or O_RDWR -
    //O_NDELAY (geht weiter, wenn keine Daten da sind und gibt "-1" zurueck)
    // man 2 open fuer mehr Infos - see "man 2 open" for more info
    // O_NOCTTY No ControllTeleType 
    fd = open(MODEMDEVICE, O_WRONLY | O_NOCTTY);
    
    if (fd < 0)
    {
        printf("Fehler beim öffnen von %s\n", MODEMDEVICE);
        exit(-1);
    }
    
    memset(&newtio, 0, sizeof(newtio));
    newtio.c_cflag = BAUDRATE | CS8 | CLOCAL | CREAD;                                                    // Setzt die neuen Porteinstellungen
    newtio.c_iflag = IGNPAR;
    newtio.c_oflag = 0;
    newtio.c_lflag = 0;         /* set input mode (non-canonical, no echo, ...) */
    newtio.c_cc[VTIME] = 0;     /* inter-character timer unused */
    newtio.c_cc[VMIN] = 1;    /* blocking read until 1 chars received */


    tcflush(fd, TCIFLUSH);
    tcsetattr(fd, TCSANOW, &newtio);
    return fd;
}

Immer derselbe für jedes Programm wo man den UART verwenden will?
Im Moment lasse ich die Baudrate noch bei 115200, weil das die Defaulteinstellung für die Baudrate ist und ich noch kein Teil im Startscript habe um die Baudrate umzustellen.
Morgen wollte ich dann auf meiner Homepage noch eine Anleitung schreiben wie man den UART per Web verwendet und wollte deinen Namen da erwähnen, weil du einen nicht zu vernachlässigen Anteil an der Problemlösung (und dem Verständnis) beigetragen hast, wenn du nichts dagegen hast

Edit:
Mittlerweile habe ich es auch geschafft meine eigene Sendenroutine zu implementieren.
Bei dem Befehl:

res=write(fd, &c[Counter], 1);

Dort wo jetzt &c[Counter] steht, wird ein Pointer erwartet und deswegen wird dort der Inhalt der Speicherzelle, die für &c[Counter] steht, übergeben?
Sehe ich das so richtig?
Und dann noch eine Frage zu der Variable "fd". Diese steht ja für den Filedescriptor und wird bei der Write Funktion an der Stelle erwartet.
Und diese Variable nimmt den Wert 0 an wenn der UART erfolgreich geöffnet wurde?

[Klebwax]

Mittlerweile habe ich es auch geschafft meine eigene Sendenroutine zu implementieren.
Bei dem Befehl:
einfach
res=write(fd, &c[Counter], 1);

Dort wo jetzt &c[Counter] steht, wird ein Pointer erwartet und deswegen wird dort der Inhalt der Speicherzelle, die für &c[Counter] steht, übergeben?
Sehe ich das so richtig?
Und dann noch eine Frage zu der Variable "fd". Diese steht ja für den Filedescriptor und wird bei der Write Funktion an der Stelle erwartet.
Und diese Variable nimmt den Wert 0 an wenn der UART erfolgreich geöffnet wurde?

Nein, es ist ein Index für den offenen File. Jeder offene File hat eine eigene Nummer. Ohne die wüßte write ja nicht, wohin es schreiben soll. Hat auch mit UART direkt nichts zu tun, das ist auch nur ein File.

Versuchs doch mal mit "man write", und wenn du die man-pages nicht auf deinem System hast, einfach in Google.

Wenn man etwas menschenlesbares ausgeben will, ist häufig fprintf() einfacher zu benutzen.

MfG Klebwax

[Kampi]

Ah ok.
Sprich mit der Zeile

fd = open(MODEMDEVICE, O_WRONLY | O_NOCTTY);

wird ein File geöffnet welches durch Modemdevice deklariert wurde. Dieses File ist in dem Programm ttyAMA0. Anschließend wird gesagt, das man dort nur reinschreiben will.
Und die Zahl die dem File dann zugewiesen wird, wird unter "fd" gespeichert?
Und ich vergesse immer wieder, dass bei dieser Geschichte alles über Dateien abläuft
Bin noch bisl zu sehr an µC gewöhnt wo man direkt den UART anspricht. Das das unter dem Linux über eine Datei abläuft und nicht direkt über den UART vergesse ich gerne
Ist halt doch ein bischen was anderes als eine 8-Bit Maschine.....gerade was solche Sachen angeht.
Ich wusste z.B. auch nicht, dass man mit argc und argv Daten in eine Mainloop übergeben kann. Ich kenne C bisher nur von 8-Bit Controllern und dort wird sowas (meines Wissens nach) nicht benutzt.
Aber schön das man durch sowas banales wie den UART benutzen noch so eine ganze Menge lernen kann ^.^

Edit: Da war der Peter etwas fixer
Ja die Baudrate senke ich denke ich mal auch noch, da auch ich kein Baudratenquarz benutze.
Aber gut....dann verwende ich die "Init"-Routine einfach so weiter. Wollte nur sicher gehen, nicht das es in anderen Programmen dann nicht funktioniert und ich Suche mich doof

[peterfido]

In der Init() wird die Schnittstelle zum Schreiben geöffnet. Möchtest Du lesen und schreiben, dann wird entweder

fd = open(MODEMDEVICE, O_WRONLY | O_NOCTTY);
.
.
.
newtio.c_cc[VMIN] = 1;    /* blocking read until 1 chars received */

gegen

fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY);
.
.
.
.
newtio.c_cc[VMIN] = 0;    /* blocking read until 1 chars received */

getauscht oder du öffnest die Schnittstelle ein zweites Mal nur zum lesen. Die zweite Änderung (newtio.c_cc[VMIN] = 0; ) braucht es dann aber trotzdem, damit
das Programm nicht beim Read blockiert wird, wenn nichts kommt. Dafür steigt dann durch das ständige Einlesen der UART die Prozessorlast.

Die Init(); Sub habe ich im Internet gefunden und da sie funktionierte, habe ich sie so belassen. Möglich, dass diese noch optimiert werden kann. Bei C werden überwiegend nur
die Adressen statt der Inhalte der Variablen übergeben. Es wird also die Schnittstelle geöffnet und die Adresse in fd zurückgegeben. Da schreibt dann die send(); immer nur ein Zeichen
rein und dieses wird dann unmittelbar über UART ausgegeben. Mehrere Zeichen "auf einmal" senden habe ich nicht probiert. Möglich, dass der Output Buffer irgendwann überläuft.

Tritt beim Senden kein Fehler auf, wird als Ergebnis (res Abkürzung für result) 0 zurückgegeben.

int res=write(fd, &c, 1);

Diese Schleife

        while(pBuf && *pBuf){                                            //Zeichen einzeln senden
            send(*pBuf++);

habe ich auch im Netz gefunden. Man könnte auch die Zeichen gleich in der Schleife, wo die Umlaute angepasst werden, senden. Das hatte ich zwischendurch auch im kombinierten Senden/Empfangen Programm gemacht. Habe diese Idee dann aber, wie gesagt wegen der Prozessorlast, wieder verworfen.

Die Geschwindigkeit hatte ich Anfangs auf 38400 Baud. Später habe ich mich dann bei 19200 eingependelt. 115200 würde mein AVR nicht schaffen (die Abweichung wäre zu hoch), da ich kein Baudratenquarz nutze.
19200 ist für meine Anwendung noch ausreichend schnell und ich habe noch vor, den TX-Pin des Raspi mit 2 parallel geschalteten RX zu verbinden, da ich noch eine externe Uhr ansteuern möchte. Da ist das Kabel dann knapp 1m lang. Da ist langsamer besser.

Ansonsten ist C noch recht neu für mich..