-         

Seite 1 von 5 123 ... LetzteLetzte
Ergebnis 1 bis 10 von 44

Thema: Internetradio

  1. #1
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    18.05.2007
    Ort
    Berlin
    Alter
    46
    Beiträge
    765

    Internetradio

    Anzeige

    Ich arbeite gerade an einem Internetradio über den Raspberry.

    Nach dieser Seite die Treiber installiert.
    Code:
    apt-get install alsa-utils ntpdate mpg123 python-virtualenv libshout3 libshout3-dev pkg-config python-dev
    In der /etc/rc.local noch den Audioausgang und die Lautstärke gesetzt.
    Code:
    amixer cset numid=3 1
    amixer -c 0 cset numid=2 on,off
    amixer set PCM 96%
    aplay /usr/games/start.wav
    Der letzte Befehl spielt eine kleine Wavedatei (aus dem Windows/media Ordner geklaut, die kleinste Datei) ab, so ist das Grundrauschen nach dem Start weg.

    Dann habe ich mit ein paar Scripten experimentiert.

    /var/scripte/mp3
    Code:
    #!/bin/bash 
    #
    # MP3 Datei abspielen
    #
    # 
    
    text="$*"
    /var/scripte/mp3stop
    /var/scripte/mp3play "$text" &
    
    exit 0
    Spielt eine MP3 Datei ab.

    Code:
    #!/bin/sh
    #
    # MP3 stoppen
    #
    # 
    pkill -9 mpg123
    
    exit 0
    Beendet die akuelle MP3

    Dann habe ich mir ein paar Radio URLs herausgesucht und in der Datei radiosender gespeichert
    Code:
    "ffn comedy"=http://rs26.stream24.org:80/stream
    "Radio ffn"=http://rs35.stream24.org:80/stream
    "NDR2"=http://ndrstream.ic.llnwd.net/stream/ndrstream_ndr2_hi_mp3
    Aufgerufen werden diese (Hier als Beispiel ffn Comedy) per
    Code:
    /var/scripte/radio comedy
    Das Script radio sieht so aus
    Code:
    #!/bin/bash 
    #
    # Radio starten
    #
    # 
    sender="$*";
    logdatei="/var/scripte/radiosender";
    # Prüfen ob Konfigurationsdatei vorhanden
    
    if [ -e $logdatei ]; then
    #        loginhalt=$(cat $logdatei)
            text=$(grep -i "$sender" $logdatei |tail -1 | cut -d= -f1);
            echo Sender: $text;
            grep -i "$sender" $logdatei |tail -1 | cut -d= -f2 > "/tmp/radiourl";
            /var/scripte/mp3stop
            /var/scripte/radioplay "-q -@ /tmp/radiourl" &
    fi
    
    exit 0
    Hier wird nach dem Teil des Sendernamens gesucht und die SenderURL in die Datei /tmp/radiourl geschrieben.

    Die radioplay sieht so aus:
    Code:
    #!/bin/bash
    #
    # MP3-Radio abspielen
    #
    # 
    
    text="$*" 
    mpg123 -q -b 1024 -h 400 -d 399 $text
    
    exit 0
    Den Aufruf an sich konnte ich bisher nicht mit der mp3play kombinieren, da ich nicht herausgefunden habe, wie ich prüfe, ob im Übergabeparameter "" sind.
    Das -h 400 -d 399 verlangsamt die Ausgabe minimal, da bei meinen beiden Raspberrys sonst nach einiger Zeit kurze Aussetzer kommen, da wohl etwas schneller abgespielt wird, als Daten reinkommen.

    Die anderen Zwischenscripte habe ich gewählt, damit im Hintergrund abgespielt wird und der Raspberry so weitere Befehle annimmt.

    Ich teste alles als User root.

    Setze ich die Lautstärke auf 0 (amixer set PCM 0%), ist trotzdem noch ganz leise was zu hören. Auch sind bei voller Lautstärke Nebengeräusche vorhanden, damit kann ich aber leben.

    Jetzt Suche ich noch nach einer Lösung, wie ich das per RS232 steuern kann, da ich noch einen Atmega als Frontend für die Fernbedienung und das Display nutzen möchte.
    Zum AVR senden ist kein Problem. Das Empfangen bereitet mir noch etwas Kopfzerbrechen. Zur Zeit öffne ich die serielle Schnittstelle mittels

    Code:
    #!/bin/bash 
    #
    # Serielle Ausgabe zum AVR
    #
    # 
    
    #text="$*"
    #echo $text > /dev/ttyAMA0
    
    echo "17" > /sys/class/gpio/export
    echo "in" > /sys/class/gpio/gpio17/direction
    chmod 555 /sys/class/gpio/gpio17/value
    chmod 555 /sys/class/gpio/gpio17/direction
    
    stty 38400 -F /dev/ttyAMA0
    
    echo "" >> /dev/ttyAMA0
    echo "" >> /dev/ttyAMA0
    echo "" >> /dev/ttyAMA0
    echo "" >> /dev/ttyAMA0
    echo "" >> /dev/ttyAMA0
    echo "" >> /dev/ttyAMA0
    
    
    echo "Bereit" >> /dev/ttyAMA0
    
    (cat /dev/ttyAMA0) > /tmp/empfang
    
    #ersetzt durch
    nice -1 /var/scripte/empfangen &
    
    
    exit 0
    So bleibt die Schnittstelle offen und die Übertragung zum AVR ist sauber. Lasse ich den cat Befehl weg, wird jedesmal die serielle Schnittstelle geöffnet, wenn per echo gesendet werden soll und am AVR kommt meist ein CHR(255) an.

    /* erledigt: Im Prinzip müsste ich jetzt statt des cat Befehls per loop die serielle immer wieder einlesen, bis CHR(13) kommt und dann auswerten. Falls da jemand helfen kann, würde ich mich freuen.


    Später soll die radiosender URL Datei noch per Webbrowser änderbar sein, ist im Moment aber nicht so wichtig und stellt soweit auch kein Problem für mich dar.
    Geändert von peterfido (21.08.2012 um 13:29 Uhr)
    Wenn das Herz involviert ist, steht die Logik außen vor! \/

  2. #2
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    18.05.2007
    Ort
    Berlin
    Alter
    46
    Beiträge
    765
    So, ich habe es in der Zwischenzeit hinbekommen.
    Ich habe mir mittels GCC ein Programm erstellt, welches die serielle Schnittstelle einliest und nach dem Empfang von chr(13) in eine Textdatei schreibt und anschließend ein BashScript ausführt, welches ich nach und nach erweitere. Das BashScript löscht dann die Eingangsdatei wieder.

    Gesendet wird weiterhin einfach per echo.
    Wenn das Herz involviert ist, steht die Logik außen vor! \/

  3. #3
    Moderator Robotik Einstein Avatar von Kampi
    Registriert seit
    21.11.2009
    Ort
    Monheim, Nordrhein-Westfalen, Germany
    Alter
    27
    Beiträge
    3.517
    Blog-Einträge
    9
    Schön das es nun funktioniert
    Ich mach mal ein Sticky dran, dann steht es oben und verschwindet nicht so schnell. Dann können es die anderen User auch mal ausprobieren.
    Schaut ruhig mal auf meiner Homepage vorbei :
    http://kampis-elektroecke.de

    Oder folge mir auf Google+:
    Daniel Kampert

    Es gibt 10 Arten von Menschen. Die einen können Binär, die anderen nicht.

    Gruß
    Daniel

  4. #4
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    18.05.2007
    Ort
    Berlin
    Alter
    46
    Beiträge
    765
    Hallo, danke für Sticky. Ist dann schon mein Zweiter neben dem im T-Hack Forum, wo ich das Frontend für mein jetziges Internetradio im X300T programmiert habe.

    Ich bin wieder weg vom mpg123. Denn der Trick mit dem verzögerten abspielen klappt nur bei wenigen Sendern, ist mir aber erst später aufgefallen, da ich beim Testen immer ffn comedy gehört hatte...

    Jetzt nutze ich den mpd, welchen ich per mpc steuere.:

    Code:
    apt-get update
    apt-get upgrade
    
    apt-get install mpd mpc
    Das upgrade war ~118MB und benötigt, einiges an Platz. Ich habe dafür dann die 2GB SD-Karte gegen eine 8GB SD-Karte ausgetauscht..

    Meine Scripte und Programme liegen alle unter /var/scripte.

    Nach der Installation von mpd und mpc wird eine playlist benötigt. Diese habe ich nach /var/lib/mpd/playlists kopiert. Die Rechte gleich wieder auf 644.
    Code:
    chmod 644 /var/lib/mpd/playlists/radiosender.m3u
    Diese sieht zur Zeit so aus:
    Code:
    http://rs26.stream24.org:80/stream
    http://rs35.stream24.org:80/stream
    http://stream.hoerradar.de:80/mp3-128_hra-nds
    http://ndrstream.ic.llnwd.net/stream/ndrstream_ndr2_hi_mp3
    http://ndrstream.ic.llnwd.net/stream/ndrstream_n-joy_hi_mp3
    http://rbb.ic.llnwd.net/stream/rbb_fritz_mp3_m_a
    http://d85195728.i.tis.core005.cdn.streamfarm.net:80/22005mdrsputnik/live/3087mdr_sputnik_live/de_96.mp3
    http://www.energyradio.de/rock
    http://www.energyradio.de/berlin
    In mpd dann noch die Konfiguration anpassen.
    Code:
    nano /etc/mpd.conf
    Bei audio_output habe ich folgendes angepasst:
    Code:
    audio_output {
            type            "alsa"
            name            "My ALSA Device"
            auto_resample   "no"
            device          "hw:0,0"        # optional
            format          "44100:16:2"    # optional
            mixer_device    "default"       # optional
            mixer_control   "PCM"           # optional
            mixer_index     "0"             # optional
            period_time     "5000"        # Soll Knackser minimieren, experimentiere noch mit dem Wert
    }
    Hinweis: Laut meinen Recherchen soll der analoge Audioausgang nur aktiv sein, wenn keine HDMI Verbindung steht.

    Anschließend schonmal per
    Code:
    mpc load radiosender
    die Liste in mpd einlesen. Diese Liste merkt sich mpd auch über einen Neustart hinaus, bzw hängt sie bei jedem Aufruf zusätzlich hinten dran.
    Testen, ob das abspielen läuft:
    Code:
    mpc play 1
    spielt den ersten Eintrag in der Liste ab.
    Code:
    mpc stop
    beendet die Wiedergabe, bzw. pausiert, denn mit
    Code:
    mpc play
    wird die Wiedergabe des zuletzt gewählten Senders fortgesetzt.

    Wenn das alles läuft, kann man sich der externen Ansteuerung widmen. Welche bei mir aus 3 Programmen besteht.
    1. Entgegennahme der Befehle vom AVR:
    Code:
    // Compile with: GCC /var/scripte/empfangen.c -o /var/scripte/empfangen
    
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <termios.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    
    
    #define BAUDRATE B19200
    char MODEMDEVICE[]= "/dev/ttyAMA0";                        // Schnittstelle
    char FILEDEVICE[]= "/tmp/empfang.txt";                    // letztes Empfangenen in Datei schreiben, für evtl. BASH-Auswertung
    //char AUSFUEHREN[32]= "/var/scripte/seriell.sh";            // BASH Script zum Auswerten der Daten
    //char RADIOSPIELEN[32]="nice -1 /var/scripte/radio2.sh &"; // BASH Script zum abspielen
    //char RADIODEVICE[32]= "/var/scripte/radiosender";            // Senderliste
    char FARBDEVICE[]="/tmp/webif.farbe";                     // Dateiname für php Farben
    //char SENDERDEVICE[32]="/tmp/radiourl";                    // URL zum abspielen für mpg123 ablegen
    
    
    
    /*
    Sx          x=0 aktuellen Sender neu abspielen Nach Stop oder zum neu puffern, x>49 Sender x-48 abspielen
    Bx          x=0 abspielen stoppen, x=1 Senderliste neu laden, x=2 mpd neu starten
    Px            x=0 einen Senderplatz zurück x=1 einen Senderplatz hoch
    Frrggbb        gesetzte Farben für php in Datei ablegen
    resetreset     Reboot des Raspi
    */
    char eingang[255]="";
    char d[1]="";
    int anzahl=0;
        
    int laenge=0;
    int logg=0;
    int    fd;                // File descriptor
    int sender;
    
    struct    termios newtio={};
    
    unsigned char send()
    { int i;    
      int fd1;
      char ret;
      /* Zum Schreiben öffnen */
    
      fd1 = open (FILEDEVICE, O_WRONLY|O_CREAT|O_TRUNC);
      if (fd1 == -1)
        exit (-1);
      write (fd1, eingang, laenge);
      close (fd1); 
      system("chmod 644 /tmp/empfang.txt");
      if (logg==1){
      printf("AVR: %s\n",eingang);    
      }
      //system(AUSFUEHREN);
      for(i=0; i < laenge; i++)
        {
            eingang[i] = 0;
        }
      laenge=0;    
    }
    
    unsigned char radioein()
    { 
        //int i=0;    
        char nummer[1];
    //  char sender_name[30]="";
        char befehl[255]="";
    /*    FILE *f;
        char Text[300]="";
        f = fopen(RADIODEVICE,"r");
            if(f==NULL)
            {
            printf("Fehler beim Oeffnen! Bitte ueberpruefe deinen Pfad!\n");
            }
            i=0;
            while( fgets(Text, sizeof(Text), f) !=0 ){
                i++;
                if (i==sender){
                    
                    strcpy(sender_name,"1");
                    strcat(sender_name,Text);
                    if (logg==1){                
                        printf("Sendername: %s\n",sender_name);    
                    }
                    //            system(RADIOSPIELEN);
                    
                    strcpy(befehl,"/var/scripte/senden ");
                    strcat(befehl,sender_name);
                    system(befehl);
                }
            }
        fclose(f);
    */    
        sprintf(nummer,"%d",sender);
        strcpy(befehl,"mpc -q play ");
        strcat(befehl,nummer);
        system(befehl);
        
    }
    
    
    unsigned char initmpd()
    {
        int i=0;    
    
        system("mpc stop");
        system("mpc playlist > /tmp/mpdlist");
        sleep(1);
        FILE *f;
        char Text[300]="";
        char Text1[70]="";
        char Text2[7]="volume";
        f = fopen("/tmp/mpdlist","r");
        anzahl=0;
        if(f!=NULL){
            fgets(Text, sizeof(Text), f);
            if(strlen(Text)<2){
                fclose(f);
                system("mpc clear");
                system("mpc load radiosender");            
                initmpd();
                return;
            }else{
                anzahl=1;
                while( fgets(Text, sizeof(Text), f) !=0 ){
                    anzahl++;
                }
            }
            fclose(f);
            if(anzahl>200){
                initmpd();
                return;
            }
        }
    }
    
    unsigned char auswerten()
    { int i;    
      int fd1;
      int zeile;
      char ret;
      char farbe[6]="";
      
      /* Zum Schreiben öffnen */
        if ((strcmp(eingang,"resetreset") ==0 )){
            system("reboot");
        }
        if ((strcmp(eingang,"B1") ==0 )){
            initmpd();
        }
        if (eingang[0] == 70){                              // F
          fd1 = open (FARBDEVICE, O_WRONLY|O_CREAT|O_TRUNC); //|O_TRUNC, S_IRUSR|S_IWUSR
          if (fd1 == -1)
            exit (-1);
    
          for(i=0; i<=6; i++)
            {
                farbe[i]=eingang[i+1];
            }    
          
          write (fd1, farbe, 6);
          close (fd1); 
          system("chmod 644 /tmp/webif.farbe");
    
        }
        if (eingang[0] == 83){                              // S
            zeile=eingang[1]-48;                            //Werte von 48-255 = 207 Sender
            if (zeile == 0){                            // 0
                system("mpc -q play");
            }else if (zeile<=anzahl){
                sender=zeile;
                radioein();
            }
          }
        if (eingang[0] == 80){                              // P
            if (eingang[1]==49){                             //1
                sender++;
                if (sender>anzahl){
                    sender=1;
                }
            }else{
                sender--;
                if (sender<1){
                    sender=anzahl;
                }
            }
            radioein();
          }
        if (eingang[0] == 66){                              // B
            if (eingang[1]==48){                             //0
                system("mpc stop");
                sleep(1);
            //    system("/var/scripte/senden 0");            // Macht jetzt mpcout für tatsächlichen Zustand
            }
            if (eingang[1]==49){                             //1 Senderliste neu laden
                system("mpc clear");
                initmpd();
            }
            if (eingang[1]==50){                             //2 mpd neu starten
                system("/etc/init.d/mpd restart");
            }
        }
        eingang[laenge]=10;                                    //Zeilenvorschub
        laenge++;
        send();
     }
    
    unsigned char receive()
    {
        int res;
        unsigned char buffer;
    
        res = read(fd, &buffer, 1);
        return buffer;
    }
    
    int init()
    {
        /*** 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 
        /*fd1 = open(FILEDEVICE, O_WRONLY);
        if (fd1 < 0){
            printf("Fehler beim oeffnen von %s\n", FILEDEVICE);
            exit(-1);
        }*/
        
        fd = open(MODEMDEVICE, O_RDONLY | 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 main(int argc, char** argv)
    {
        char c;
    
         init();
        sleep(8);             //warten bis mpd gestartet ist
         initmpd();
    
        while (1)
            {
            c=receive();
            if((c==13)){
                auswerten();
            }else if(c>13){
                eingang[laenge]=c;
                laenge++;
                if (laenge >254){
                    auswerten();
                }
            }
        } 
        close (fd);
        return 0;
    }
    2. Befehle zum AVR senden:
    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)
    {
        int res=write(fd, &c, 1);
        if (res<0) printf("Fehler beim Senden\n");
        return res;
    }
    
    int init()
    {
        /*** 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 main(int argc, char** argv)
    {
        char c;
        char vBuf[80]="",*pBuf;
        char buffer [80];
        int i=0;
         init();
        if (argc == 1) {                                                    //Wenn nichts angegeben, dann Uhrzeit und Datum senden
            time_t rawtime;
            struct tm * timeinfo;
    
            time ( &rawtime );
            timeinfo = localtime ( &rawtime );
    
            strftime (buffer,80,"U%H:%M:%S",timeinfo);                        //Uhh:mm:ss
            pBuf=buffer;
            strcat(pBuf,"\r");
            while(pBuf && *pBuf)                                            //Zeichen einzeln senden
                send(*pBuf++);
    
            strftime (buffer,80,"D%d.%m.%y",timeinfo);                        //Dtt.mm.yy
            pBuf=buffer;
            strcat(pBuf,"\r");
            sleep(1);
            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
                strncpy(buffer,argv[1],76);                
                buffer[76]='\0';
            }else{
                strcpy(buffer,argv[1]);
                if (argc >2){
                    for (i=2;i<argc;i++){
                        if(strlen(buffer)+strlen(argv[i])>75){
                            strcat(buffer," ");                                
                            strncat(buffer,argv[i],(76-strlen(buffer)));
                            buffer[76]='\0';
                            break;                                            //exit for in c...
                        }else{
                            strcat(buffer," ");
                            strcat(buffer,argv[i]);
                        }
                    }
                }
            }
            pBuf=buffer;
            strcat(pBuf,"\r");                                                //CHR(13) anfügen, damit der AVR auswertet        
            while(pBuf && *pBuf){                                            //Zeichen einzeln senden
                send(*pBuf++);
            }
        } 
        close (fd);
        return 0;
    }
    3. mpd überwachen und Status, bzw Titel zum AVR senden.
    Code:
    // Compile with: GCC /var/scripte/mpcout.c -o /var/scripte/mpcout
    
    //#include <sys/types.h>
    //#include <sys/stat.h>
    //#include <fcntl.h>
    //#include <termios.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    //#include <unistd.h>
    
    
    char Textalt[75]="";
    //char SENDERDEVICE[32]="/tmp/mpcout";
    
    unsigned char aktualisieren()
    {     
        int i=0;    
        int o=0;
        char befehl[255]="";
        system("mpc current > /tmp/mpcout");
        sleep(1);
        FILE *f;
        char Text[300]="";
        char Text1[75]="";
    //    char Text2[7]="volume";            //Ausgabe, wenn nichts gespielt wird - wegen Parameter current nicht mehr nötig.
        f = fopen("/tmp/mpcout","r");
        if(f!=NULL){
            fgets(Text, sizeof(Text), f);
            if(strlen(Text)<2){
                strcpy(Text1,"");
                if((strcmp(Text1, Textalt)) != 0){
                    strcpy(Textalt, Text1);
                    system("/var/scripte/senden 0");
                }
            }else{
                o=0;
                for (i=0;i<strlen(Text);i++){
                    Text1[o]=Text[i];
                    //if (Text[i]==32||Text[i]==45||Text[i]==46||Text[i]>=48&&Text[i]<=59||Text[i]>=65&&Text[i]<=90||Text[i]>=97&&Text[i]<=122||Text[i]>=127&&Text[i]<=252){    //Parsen
                        o++;
                    //}
                    if (o>74){
                        break;
                    }
                }
                Text1[o]='\0';
                if((strcmp(Text1, Textalt)) != 0){
                    strcpy(Textalt, Text1);
        //            if(strncmp(Text,Text2,6) != 0){                    //wegen Parameter current nicht mehr nötig.
                        strcpy(befehl,"/var/scripte/senden '1");    // \" funktioniert nicht, ' schon
                        strcat(befehl,Text1);
                        strcat(befehl,"'");
                        system(befehl);
        //            }                                                //wegen Parameter current nicht mehr nötig.
                }
            }
        }
        fclose(f);
    }
    
    int main(int argc, char** argv)
    {
        char c;
    /*f (argc > 1){
            logg=1;
            printf("Logging Modus ein %s\n",LOGDEVICE);
        }*/
        
        while (1)
            {     sleep(2);
                aktualisieren();
        } 
        return 0;
    }
    Kompiliert habe ich die Programme per gcc. Wenn der Code für den einen oder anderen optimierungsbedürftig aussieht, kann er das gerne machen. Diskussionen über C-Programmierung bitte in einem anderen Thread. Ich bin froh, dass es bisher fehlerfrei läuft. C gehört nicht zu meinen Favoriten.

    Aufgerufen werden diese in der /etc/rc.local: (Ausschnitt)
    Code:
    nice -1 /var/scripte/empfangen &
    nice -1 /var/scripte/mpcout &
    /etc/init.d/mpd restart
    /etc/init.d/apache2 restart
    aplay /usr/games/start.wav
    Der vorletzte Befehl startet den Apache nochmal neu, was hier eigentlich nicht von nutzen ist, und der letzte siganlisiert dann über die Lautsprecher, dass der Raspi fast fertig hochgefahren ist.


    Hinweis:
    Ich nutze die UART auf der Stiftleiste. Für einen USB-Seriell Adapter sind folgende Schritte nicht notwendig!
    Damit die UART frei ist, müssen 2 Dateien angepasst werden. Achtung: Vorher sichern. Wenn was schief geht, kann ich die SD-Karte in meinem NAS mounten und die Sicherungen zurückspielen...
    /boot/cmdline.txt:
    Code:
    dwc_otg.lpm_enable=0 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait
    /ect/inittab: Folgende Zeile auskommentieren
    Code:
    T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100
    zu
    Code:
    #T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100
    Und natürlich auch alle anderen Zeilen, welche auf ttyAMA0 zugreifen wollen.
    Geändert von peterfido (24.08.2012 um 13:27 Uhr)
    Wenn das Herz involviert ist, steht die Logik außen vor! \/

  5. #5
    Erfahrener Benutzer Roboter Experte Avatar von ePyx
    Registriert seit
    14.05.2008
    Ort
    Falkensee
    Beiträge
    700
    Warum schreibst du eigentlich keinen Wiki-Artikel über dein Projekt? Den Sticky-Thread kannst du dann ja als Möglichkeit zur Diskussion nutzen.
    Grüße,
    Daniel

  6. #6
    Moderator Robotik Einstein Avatar von Kampi
    Registriert seit
    21.11.2009
    Ort
    Monheim, Nordrhein-Westfalen, Germany
    Alter
    27
    Beiträge
    3.517
    Blog-Einträge
    9
    Zitat Zitat von ePyx Beitrag anzeigen
    Warum schreibst du eigentlich keinen Wiki-Artikel über dein Projekt? Den Sticky-Thread kannst du dann ja als Möglichkeit zur Diskussion nutzen.
    Dem muss ich zustimmen. Wäre toll wenn du es ins RN-Wiki zum Thema "Embedded Linux Einstieg" integrieren könntest (neuer Wikiartikel und beim Embedded Linux Einstieg nen Link o.ä. zu dem Thema).
    Natürlich nur wenn du Zeit und Lust dazu hast
    Schaut ruhig mal auf meiner Homepage vorbei :
    http://kampis-elektroecke.de

    Oder folge mir auf Google+:
    Daniel Kampert

    Es gibt 10 Arten von Menschen. Die einen können Binär, die anderen nicht.

    Gruß
    Daniel

  7. #7
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    18.05.2007
    Ort
    Berlin
    Alter
    46
    Beiträge
    765
    Im Prinzip wäre das dann diesen Thread nochmal zusammenzufassen?

    Das sehe ich mir demnächst mal näher an.

  8. #8
    Moderator Robotik Einstein Avatar von Kampi
    Registriert seit
    21.11.2009
    Ort
    Monheim, Nordrhein-Westfalen, Germany
    Alter
    27
    Beiträge
    3.517
    Blog-Einträge
    9
    Ja genau. Ein paar Erklärungen noch was du wo gemacht hast, so das ein Anfänger das problemlos nachmachen kann
    Schaut ruhig mal auf meiner Homepage vorbei :
    http://kampis-elektroecke.de

    Oder folge mir auf Google+:
    Daniel Kampert

    Es gibt 10 Arten von Menschen. Die einen können Binär, die anderen nicht.

    Gruß
    Daniel

  9. #9
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    18.05.2007
    Ort
    Berlin
    Alter
    46
    Beiträge
    765
    Ja, das geht. Allerdings wird es noch etwas dauern, da ich dann dafür auf einer jungfräulichen SD-Karte alles nochmal neu machen werde, damit ich nichts vergesse.
    Wenn das Herz involviert ist, steht die Logik außen vor! \/

  10. #10
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    18.05.2007
    Ort
    Berlin
    Alter
    46
    Beiträge
    765
    Da die Software jetzt soweit steht, kümmere ich mich grad um die Hardware. Den Bufferunderrun habe ich wie erwartet bei HDMI nicht. Da das Signal nicht durch den DAC geschickt wird. Das Rauschen ist auch bei HDMI vorhanden, bis die Mixer Settings greifen. Danach absolute Stille und Radio kommt sauber rüber. Da ich jedoch nicht den ganzen Tag den Fernseher anhaben möchte, habe ich mir eben einen HDMI VGA Adapter mit Audioausgang und Netzteil bestellt. Allerdings nicht den billigen, sondern den, der soviel kostet wie der Raspi selbst auch. Wegen dem beigelegten Netzteil und der überwiegend guten Bewertungen bei Amazon.

    Man könnte natürlich auch Softwareseitig dem Bufferunderrun im Analogbetrieb entgegenkommen und einen Player mit Pitch control wählen oder, so wie ich es bisher mache, einfach den Play Befehl nochmal ausführen, dann wird neu gepuffert. Dass der Puffer leer war, habe ich daran erkannt, dass beim neustarten fast keine Verluste waren, also minimal nach der Stelle des neustarten weiterging. Man könnte den Leerlauf - Effekt herauszögern, wenn man einen großen Buffer sowie Mindestgröße einstellt. Dann dauert es aber auch jedesmal beim Erststart, Senderwechsel oder halt Neustart. Das war mir dann auf Dauer zu blöd.

    Ich frage mich gerade, wie ihr das genau mit dem Wiki Artikel meint. Soll es da mehr um Embedded Linux und Software Entwicklung gehen, oder viel mehr auf das spezielle Internetradio eingehen? Ich würde da eher das Internetradio wählen oder halt die Kombination des Raspi mit einem AVR, bzw. allgemein die Kommunikation per UART, da dem Raspi egal ist, wer tatsächlich die Daten abschickt.

    Internetradio wäre mehr ein spezieller Anwendungsfall, wobei er auch ohne Internet als MP3 Player dienen kann. MP3 über LAN (NAS) spielt er schonmal ab. Man könnte auch eine große SD-Karte, einen USB Stick oder USB-Festplatte nehmen. Wobei bei MP3 keine Probleme mit leerlaufenden Puffern auftreten.

    Da braucht es dann nur noch ein Display, ein paar Tasten und natürlich einen Verstärker. Schon hat man eine mobile Jukebox. OK - Die Software fehlt dann auch noch. Oder man bedient den mpd per Smartphone-App oder Browser. Beides habe ich nicht probiert, bin aber bei meinen Recherchen auf die Möglichkeiten gestossen.

    Die Tasten kann man auch durch eine Funktastatur ersetzen. Ich habe hier eine kleine weiße mit Touchpad und einem USB-Empfänger vom Lidl (vor 2 Jahren oder so gekauft), welches unter der gui (startx) sogar funktioniert. So braucht es dann nur noch ein Display für den komfortableren mobilen Betrieb.
    Geändert von peterfido (24.08.2012 um 22:28 Uhr)
    Wenn das Herz involviert ist, steht die Logik außen vor! \/

Seite 1 von 5 123 ... LetzteLetzte

Berechtigungen

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