- LiFePO4 Speicher Test         
Ergebnis 1 bis 10 von 52

Thema: Lighttpd + UART - Wird nichts gesendet

Baum-Darstellung

Vorheriger Beitrag Vorheriger Beitrag   Nächster Beitrag Nächster Beitrag
  1. #24
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    18.05.2007
    Ort
    Berlin
    Alter
    53
    Beiträge
    765
    Normal schon, ich habe allerdings noch keinerlei Erfahrungen auf dem Raspi mit SPI oder I²C.

    Anbei mal eine Testseite (index1.php)
    Code:
    <html>
    <head>
    <title>Raspberry Pi Server - Testseite</title>
    </head>
    <body>
    <h1>Raspberry Pi Webserver - Testseite</h1>
    <div id="nav"><a href="index.php?safemode=1">Safemode?</a><a href="index.php">Hauptseite</a> <a href="index1.php">Neu laden</a></div>
    <div id="main"><h2>Raspi Kommunikationstest<h2><br>
    <?php
    header("Cache-Control: no-cache, must-revalidate"); //cache abschalten, so dass die Seite neu geladen wird
    if (isset($_GET["safemode"])) {                    //Ermögliche, den Safemodus des php abzufragen.
        if( ini_get('safe_mode') ){
            echo "<br>Safemode an<br>";
        }else{
            echo "<br>Safemode aus<br>";
        }
    };
    if (isset($_POST["befehl"])) {                    //Wurde die Variable "befehl" gesetzt?
            if ($_POST["befehl"]!=""){                //Ist befehl nicht leer dann
                $befehl="/var/scripte/kommunikation ".$_POST["befehl"];        //Programm aufruf und die Eingabe, welche in den Postdaten der befehl-Variable steckt als Parameter anhängen
                $output = shell_exec($befehl);                                 //Durchführen des Programmaufrufes und die Antwort in output speichern
            }
    };
    echo "<form method='post' action='index1.php'>";            //Formula einleiten, nach Absenden des Textes die Seite neu laden. Dabei wird der Text dann an das Programm übergeben
    echo "<input type='text' maxlength='40' size='40' id='1' name='befehl' value='Ich' />";        //Textfeld max 40 Zeichen, name befehl
    echo "<input type='submit' value='Senden' />";                //SendenButton
    echo "<br>";                                                //Neue Zeile
    echo "Antwort: $output </form>";                            //Antwort des Programmes ausgeben, sowie Form abschließen
    ?>
    </div>
    </body>
    Diese nimmt den eingegebenen Text und schickt diesen als Parameter an /var/scripte/kommunikation
    Das muss nicht per sudo geschehen, da nichts auf die UART ausgegeben werden soll.

    /var/scripte/kommunikation.c
    Code:
    // Compile with: GCC /var/scripte/kommunikation.c -o /var/scripte/kommunikation
     
    //#include <iostream>
    //using namespace std;
    #include <sys/types.h>                        //nicht benötigtes scheint keinen Platz zu verschwenden...
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <termios.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    
    
    int main(int argc, char** argv)
    {
        if (argc >= 1) {                        //arg[0] ist der Programmaufruf an sich. Also mehr als ein Argument (Parameter), dann ist Text eingetroffen                                                
            if (strcmp(argv[1],"Ich")==0){        //Vergleich auf das Wort Ich
                printf("Du\n");                    //Bei "Ich" "Du" antworten
            }else{                                //Kein "Ich" gefunden
                if (strcmp(argv[1],"Du")==0){    //Evtl. ein "Du"?
                    printf("Ich\n");            //Ja - mit "Ich" antworten.
                }else{                            //Weder ein Ich noch ein Du erkannt
                    printf("Keiner\n");            //"Keiner" Antworten
                }
            }
        }
        return 0;                                
    }
    Also ein einfacher Kommunikationstest. Wichtig ist, dass die Seite als index1.php gespeichert (und dann auch aufgerufen wird). Die Rechte nicht vergessen.

    Das Senden Programm weiter oben sendet die Zeichen einzeln in der
    Code:
    unsigned char send(char c)
    {
        int res=write(fd, &c, 1);
        if (res<0) printf("Fehler beim Senden\n");
        return res;
    }
    Init öffnet die Schnittstelle und parametriert diese.
    In der Main werden die Parameter abgefragt und evtl. Sonderzeichen angepasst. Dann wird das char Array pBuf, welches den zu sendenden Text enthält Zeichenweise per send an der UART ausgegeben.

    Hier nochmal das Senden Programm mit Kommentaren:
    Code:
    // Compile with: GCC /var/scripte/senden.c -o /var/scripte/senden
     
    //#include <iostream>
    //using namespace std;
    #include <sys/types.h>                        //nicht benötigtes scheint keinen Platz zu verschwenden...
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <termios.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <time.h>
    
    #define BAUDRATE B19200
    char MODEMDEVICE[]= "/dev/ttyAMA0";    // !!!
    
    int    fd;                // File descriptor
    struct    termios newtio={};
    
    unsigned char send(char c)                        //gibt ein einzelnes Zeichen über UART (als fd geöffnet) aus.
    {
        int res=write(fd, &c, 1);                    //Zeichen ausgeben
        if (res<0) printf("Fehler beim Senden\n");    //Fehler aufgetreten
        return res;
    }
    
    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 oeffnen 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;
    }
    int einmal()                                //Prüfen, ob das Programm schon läuft und die Instanzen zählen
    {
        int i=0;
        int anzahl=0;
        int laenge=0;
        char *ptr;
        FILE *in;
        extern FILE *popen();
        char buff[30];
        char rueckgabe[30]="";
    
        if(!(in = popen("pidof senden", "r"))){        //PID abfragen
            exit(1);
        }
        
        fgets(buff, sizeof(buff), in);
        pclose(in);
        laenge=strlen(buff);
        for(i=0;i<laenge;i++)
        {
            if(buff[i]==' ') anzahl++;            //Zwischen den PIDs sind Leerzeichen. Einmal diese Instanz und pro weitere Instanz ein Leerzeichen
        }
        return anzahl;    
    }
    
    
    int main(int argc, char** argv)                //Programmstart
    {
        char c;                                    //in c passt ein einzelnes Zeichen zum versenden
        char vBuf[100]="",*pBuf;                //Evtl. Buffer vergrößern, sonst Schutzverletzung
        char buffer [100]="";                    //""
        char buffer1 [100]="";                    //""
        int i=0;                            
        int anzahl;
        anzahl=einmal();                        //Anzahl der Instanzen abfragen
        if (anzahl>0){                            //Bei mehreren pro Instanz eine Sekunde Pause
            anzahl++;
            sleep(anzahl);
        }
         init();                                    //Schnittstelle öffnen und parametrieren
        if (argc == 1) {                                                    //Wenn nichts angegeben, dann Uhrzeit und Datum senden
            time_t rawtime;                                                    //Zeit auslesen und formatieren
            
            struct tm * timeinfo;                                            //Zeit auslesen und formatieren
            time ( &rawtime );                                                //Zeit auslesen und formatieren
            timeinfo = localtime ( &rawtime );                                //Zeit auslesen und formatieren
    
            strftime (buffer,80,"U%H:%M:%S",timeinfo);                        //Erwartetes Uhrzeitformat: Uhh:mm:ss
            pBuf=buffer;                                                    //Zeit in buffer schieben
            strcat(pBuf,"\r");                                                //CR anhängen
            while(pBuf && *pBuf)                                            //Zeichen einzeln senden
                send(*pBuf++);
    
            strftime (buffer,80,"D%d.%m.%y",timeinfo);                        //Erwartetes Datumsformat: Dtt.mm.yy
            pBuf=buffer;                                                    //Datum in buffer schieben
            strcat(pBuf,"\r");                                                //CR anhängen    
            sleep(1);                                                        //1Sekunde warten
            while(pBuf && *pBuf)                                            //Zeichen einzeln senden
                send(*pBuf++);
        }else{                                                                //Sonst Parameter einlesen und senden    
            if(strlen(argv[1])>75){                                            //Puffer im AVR ist auf 80 gestellt. Bei mehr als 75 Zeichen wird nur der erste Parameter abgefragt
                strncpy(buffer,argv[1],76);                                    //Maximal 76 Zeichen zulassen
                buffer[76]='\0';
            }else{                                                            //Weniger als 76 Zeichen im 1. Parameter, also weitere Parameter einlesen und aneinanderhängen
                strcpy(buffer,argv[1]);                                        //Erste Paameter einlesen und in buffer ablegen
                if (argc >2){                                                //gibt es noch mehr Parameter?
                    for (i=2;i<argc;i++){                                    //alle nacheinander einlesen und anhängen
                        if(strlen(buffer)+strlen(argv[i])>75){                //Buffer plus Parameter x länge>75???
                            strcat(buffer," ");                                //Leerzeichen zwischen den Wörtern einfügen
                            strncat(buffer,argv[i],(76-strlen(buffer)));    //Ist der Text zu lang, dann bei 76 Zeichen abschneiden
                            buffer[76]='\0';                                //Textende Zeichen ist chr(0)
                            break;                                            //exit for in c...
                        }else{
                            strcat(buffer," ");                                //Weniger als 76 Zeichen? 
                            strcat(buffer,argv[i]);                            //Parameter weiter anhängen
                        }
                    }
                }
            }
            int o=0;
            for(i=0;i<strlen(buffer);i++){                                //Umlaute von UTF-8 in ASCii Codes des AVR wandeln. Dabei den Text in buffer1 ablegen
                buffer1[o]=buffer[i];
                if (buffer1[o]==164){                                    //ä
                    buffer1[o]= 228;
                }
                if (buffer1[o]==188){                                    //ü
                    buffer1[o]= 252;
                }
                if (buffer1[o]==182){                                    //ö
                    buffer1[o]= 246;
                }
                if (buffer1[o]==132){                                    //Ä
                    buffer1[o]= 196;
                }
                if (buffer1[o]==156){                                    //Ü
                    buffer1[o]= 220;
                }
                if (buffer1[o]==150){                                    //Ö
                    buffer1[o]= 214;
                }
                if (buffer1[o]==159){                                    //ß
                    buffer1[o]= 223;
                }
                if (buffer1[o]==138){                                    //&
                    buffer1[o]= 38;
                }
                if (buffer1[o] != 195){                                    //Initialisierung Umlaut weglassen
                    o++;
                }
            }
            pBuf=buffer1;                                                //pBuf nach buffer1 umbiegen
            strcat(pBuf,"\r");                                                //CHR(13) anfügen, damit der AVR auswertet        
            while(pBuf && *pBuf){                                            //Zeichen einzeln senden
                send(*pBuf++);
            }
        } 
        close (fd);
        return 0;
    }
    Geändert von peterfido (14.09.2012 um 21:54 Uhr)
    Wenn das Herz involviert ist, steht die Logik außen vor! \/

Ähnliche Themen

  1. [ERLEDIGT] MCP2515 Remoteframe wird nicht gesendet.........
    Von Kampi im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 2
    Letzter Beitrag: 30.08.2012, 22:49
  2. [ERLEDIGT] Frage zu LightTPD
    Von Kampi im Forum Raspberry Pi
    Antworten: 69
    Letzter Beitrag: 17.07.2012, 14:57
  3. Auf LC-Display wird nichts angezeigt
    Von cesupa im Forum C - Programmierung (GCC u.a.)
    Antworten: 2
    Letzter Beitrag: 28.02.2008, 18:44
  4. I2C Adapter Software es wird immer WRITE gesendet
    Von yunscher im Forum C - Programmierung (GCC u.a.)
    Antworten: 8
    Letzter Beitrag: 29.03.2007, 18:12
  5. wegen UART wird 7805 kochend heiß
    Von batti112 im Forum Elektronik
    Antworten: 26
    Letzter Beitrag: 15.06.2004, 09:48

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •  

LiFePO4 Speicher Test