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;
}
/
Zitieren
:
). Das erkennt der Empfänger und beendet den MPD Überwacher und startet ihn darauf neu, was zur Folge hat, dass alle aktuellen Werte zum 
Lesezeichen