next topic »

[Reply #30 on:]

Du kannst den "komplizierten" Teil der Berechnung ja auch das PHP übernehmen lassen, also z.B. das Berechnen der Einschalt- und Ausschaltzeit in das RTC.time2000 Format (also Sekunden seit 01.01.2000) Damit hast Du nur zwei Sekunden-Werte (32Bit Werte, also unsigned long) die Du übertragen und vergleichen musst, um die  Einschalt- und Ausschaltzeit zu haben. Das spart das ganze Wochentags und Stunden-Gerechne.
Dein Sketch hat dann pro Timer einfach zwei Werte statt nur einem für die Dauer. Wert 1 ist der time2000 Wert zum einschalten des Ventils und Wert 2 ist der time2000 Wert zum Ausschalten. Du musst nun nur jede Sekunde (besser 2x pro Sekunde, damit man den Zeitpunkt auch wirklich trifft) prüfen, ob bei irgendeinem Timer einer der Werte erreicht ist, und dann entsprechend schalten.

[Reply #31 on:]

Hallo,
ich bin mal wieder da, mit einer Frage 
Also, du schriebst:

Du kannst den "komplizierten" Teil der Berechnung ja auch das PHP übernehmen lassen, also z.B. das Berechnen der Einschalt- und Ausschaltzeit in das RTC.time2000 Format (also Sekunden seit 01.01.2000)

Das habe ich gemacht, kannst du mal schauen ob das so richtig ist ? 
Wenn ich mir den Timestamp als Datum anzeigen lasse, kommt als  kontrolle nicht das eingebene Datum raus.

Code:

<?PHP
$start = mktime(0,0,0,1,1,2000);         // Datum 01.01.2000 00:00 Uhr
$aktuell = mktime(20,58,0,6,20,2012);  // gewünschtes Datum 20.06.2012 20:58 Uhr

$neu = $aktuell - $start;

echo date("d.m.Y - H:i:s", $neu);
?>

Ich bekomme 21.06.1982 - 21:58:00 angezeigt.
Ich denke das hängt damit zusammen, das der Unix-Timestamp an 01.01.1970 rechnet.

Danke Dir/Euch

[Reply #32 on:]

Das sieht doch recht gut aus. Aus meiner Sicht sollte das passen. Du kannst ja als Kontrolle einfach den berechneten time2000 Wert mal zum Setzen der RTC verwenden und dann das Datum und die Uhrzeit auslesen. Das sollte dann nämlich stimmen.
Mario.

[Reply #33 on:]

Das sieht doch recht gut aus. Aus meiner Sicht sollte das passen. Du kannst ja als Kontrolle einfach den berechneten time2000 Wert mal zum Setzen der RTC verwenden und dann das Datum und die Uhrzeit auslesen. Das sollte dann nämlich stimmen.
Mario.

Aber wo muss ich denn den Wert eingeben ?
Habe nur Sketche gefunden, wie man das Datum und die UHrzeit eingibt, aber nicht den time2000 Wert 

[Reply #34 on:]

Noch eine Frage,
was mir gerade Einfällt/Auffällt, bei dem was ich/wir hier gerade machen, muss ich ja immer das Datum angeben. Einfacher ist es aber nur den Wochentag angeben zu müssen.
Sprich:" Montag 15:00Uhr 20min"

Weil eigentlich will ich ja garnicht das Datum übergeben, sondern den Wochentag,Uhrzeit und öffnungszeit.

Also wieder alles löschen und neu anfangen ? 

[Reply #35 on:]

Also wieder alles löschen und neu anfangen ?

Wieso löschen ? Frage ist eher, nennst du es Version 2.0 oder Version 1.1   --  Eine wichtige Marketing Entscheidung
Oder sind wir noch bei Version 0.9 ?

Die andere Frage, bisher war die "Intelligenz" auf der php Seite und Arduino kannte nur einen Einschalt-Zeitpunkt und Ausschalt-Zeitpunkt
( oder Dauer ? )  Oder ist es ganz anders ?
Das könnte natürlich so bleiben, wäre aber deutlich komplizierter, oder willst du jetzt statt eines festen Zeitpunkts (im "Time2000" Format) etwas Relatives als Schaltkriterium übergeben?

Und, soll Arduino beides können, oder ab jetzt nur noch mit Webseiten reden, die den Wochentag statt dem Datum liefern ?
Nächster Vorschlag: dann auch gleich mehrere Wochentage vorsehen: z.B. ( Mo + Mi + Fr  19:00   00:05:00)
( Der übernächste ist dann: auch mehrmals täglich )

[Reply #36 on:]

Neu anfangen würde ich auch nicht. Aber die Funktionalität erweitern ist ja kein Problem. Statt nur zwei Werten (An, Aus), bekommt der Arduino nun halt 4 Werte geschickt (Wochentag, Uhrzeit An, Wochentag, Uhrzeit aus). Das Ganze ist sogar auf drei Werte reduzierbar, wenn man die Einschränkung in Kauf nimmt, das man nicht Montag 23:45 einschalten und Dienstag 0:15 ausschalten kann, dann braucht man nur einmal den Wochentag übertragen.

Im Prinzip läuft das Ganze ja auf ein typisches "Kalender - Termine" Problem heraus. Ein "Termin" sind immer zwei Datums/Zeitangaben (in Deinem Fall fürs Ein- und Ausschalten). Termine können halt entweder Einzeltermine sein (einmalig) oder Wiederholungstermine (stündlich, täglich, wöchentlich, monatlich, jährlich etc.)
Dieses Problem würde ich Programmtechnisch einmal sauber lösen und dafür ein entsprechendes "erweitertes" Protokoll bauen, das dann in PHP und auf dem Arduino sauber implementiert wird. Idealerweise gleich als Lib, dann ist es auch für andere Aufgaben wiederverwendbar. Quasi eine Arduino-Zeitschaltuhr mit Webschnittstelle.
Mario.

[Reply #37 on:]

Idealerweise gleich als Lib, dann ist es auch für andere Aufgaben wiederverwendbar. Quasi eine Arduino-Zeitschaltuhr mit Webschnittstelle.

1. Im Prinzip vollkommen richtig. Allerdings hat derThread hier angefangen mit "Kann man eigentlich einen Pin zu einer bestimmten Zeit schalten..."
 Für den Eigenbedarf kann man auch aus einem sketch in einen anderen copy/paste wiederverwenden...

2. Eine Library sollte eine Funktion, aber die sauber, erfüllen. Ich würde daher die Funktionen "Zeitschaltuhr" und "Webschnittstelle" trennen.
 Die Zeitschaltuhr wäre damit noch universeller wiederverwendbarer...

[Reply #38 on:]

WOW bin gerade sprachlos überweltigt...

Was ihr beide da schreibt, wäre für mich Dir Bewässerung in Perfektion!

Bin gerade auf der Arbeit, melde mich später nochmal...
Cool.... 

[Reply #39 on:]

Ich habe gerade mal ein wenig über eine mögliche Datenstruktur nachgedacht, die möglichst platzsparend ist.
Ich denke mit 4 Bytes, oder genauer 64 Bit, sollte man hinkommen.

Damit kann man mit einem solchen Datensatz die Information "schalte PIN x jeden Montag um 15:35 für 10 Minuten auf HIGH" oder "schalte PIN 5 täglich alle 2 Stunden für 5 Minuten auf LOW" übertragen und speichern.

Bytes  | 1. Byte | 2. Byte | 3. Byte| 4. Byte |
       |___|_____|______|__|________|_____|___|
Bits   | 3 |  5  |   6  | 2 + 8 = 10|  5  | 3 |

• Byte 1 : codiert den Wochentag (3 Bit / 8 Werte) 1=Mo bis 7=So; 0=täglich (Sonderfall)
• Byte 1 : codiert die Stunde (5 Bit / 32 Werte) 0-23 "normale Stunde", 24-31 = Sonderfälle (z.b. stündlich, alle 2 Stunden, ... etc.)
• Byte 2 : codiert die Minuten (6 Bit / 64 Werte) 0-59 "normale Minute", Rest 60-63 wieder mögliche Sonderfälle
• Byte 2 + 3 : codiert die Schaltdauer in Minuten (2 Bit von Byte 2 + 8 Bit Byte 3 / 1024 Werte
• Byte 4 : codiert den zu schaltenden Pin ( 5 Bit / 32 Werte) 0= Pin 0, 1=Pin1 ...
• Byte 4 : codiert zusätzliche Informationen ( 3 Bit / 8 Werte) z.B. 0 -> Pin=HIGH während Schaltdauer, 1 -> Pin=LOW während Schaltdauer, etc.

Der RTC Chip hat 56 Bytes an nicht flüchtigem Speicher, damit könnte man 14 solcher Datenpakete unterbringen. Zusätzlich kann man deutlich mehr davon im EEPROM des Arduino speichern.
Verwendet man den EEPROM sollte man aber bedenken, das man nicht ständig Schreiben sollte, da die Zahl der mögliche Schreiboperationen zwar recht hoch, aber trotzdem begrenzt ist.
Andererseits bietet der EEPROM mit dem größeren Speicherplatz die Möglichkeit, die einzelnen Werte auf einzelne Bytes (oder mehrere Bytes) zu setzen, was die Verarbeitung der Werte erleichtert.

[Reply #40 on:]

Ich denke mit 4 Bytes, oder genauer 64 Bit, sollte man hinkommen.

Grandios!
Fehlt nur die Variante "mehrmals wöchentlich". ( z.B. Mo + Do ) oder so. Aber dafür kann man auch mehrere Schaltelemente vorsehen
(z.B. eines Mo von 16:00 bis 17:00 und eines Do von 19:00 bis 19:30) 
Auch muss Byte 4 eigentlich nicht wirklich dynamisch konfiguriert werden. Solche Änderungen erfordern ein Umverdrahten, was mit einer Modifikation des Sketch einhergehen könnte. Entsprechende Daten wären dann im Flash Speicher fest programmiert.

Der RTC Chip hat 56 Bytes an nicht flüchtigem Speicher, damit könnte man 14 solcher Datenpakete unterbringen

Das sollte für's erste reichen

[Reply #41 on:]

Hallo Cetax,

hier mein Sketch für das zeitgesteuerte Schalten eines Ausgangs (bei mir die Bewässerungspumpe). Zu einer am Anfang des Skripts vorgegebenen Zeit wird die Pumpe eingeschaltet und läuft dann so lange wie vorgegeben. Das Skript ist recht einfach, läßt sich aber sicherlich auf die Angabe des Wochentags erweitern. Um den DS1307 auszulesen habe ich die Bibliothek ds1307new verwendet.

Code:

// Bewässerungssteuerung
// Pumpe wird angeschlossen an pumppin und über einen Leistungs-MOSFET geschaltet.
// HIGH = Pumpe ein
//
// Die Pumpe wird täglich zur festgelegten Zeit (pumphour, pumpminute, pumpsecond)
// gestartet und nach Ablauf der vorgegebenen Zeitspanne (pumptime) wieder abgeschaltet

// *********************************************
// INCLUDE
// *********************************************
#include <Wire.h>                       // For some strange reasons, Wire.h must be included here
#include <DS1307new.h>

// *********************************************
// DEFINE
// *********************************************

// *********************************************
// VARIABLES
// *********************************************

// Anschluß für Pumpe
int pumppin = 2;

// Uhrzeit für Bewässerung
int pumphour = 21;
int pumpminute = 0;
int pumpsecond = 0;

// Bewässerungszeit in Sekunden
long pumptime = 480;

// Variable um sich die Zeit beim Einschalten der Pumpe zu merken
long timenow = 0;

// *********************************************
// SETUP
// *********************************************
void setup()
{
  pinMode(pumppin, OUTPUT);
}

// *********************************************
// MAIN (LOOP)
// *********************************************
void loop()
{
  RTC.getTime();
  // Start Pumpe
  if (int(RTC.hour) == pumphour && int(RTC.minute) == pumpminute && int(RTC.second) == pumpsecond)
  {
    digitalWrite(pumppin, HIGH);
    timenow = RTC.time2000;
  }
 
  // Stop Pumpe
  if (RTC.time2000 - timenow == pumptime)
  {
    digitalWrite(pumppin, LOW);
  }

  delay(500);                          // wait less then a second
}

Das ist die komplette Version des Schnipsels, den ich schon mal eingestellt habe. Läßt sich sicherlich schöner programmieren, aber es funktioniert.

Viele Grüße

Elektrix

[Reply #42 on:]

Hallöchen,
das ist genau das was ich vorhabe. Einfach halten 
Für mich als Anfänger ist das schon ziemlich schwierig,
Aber dank Eurer Hilfe bekomme ich das bestimmt hin   

Ich habe gerade mal ein wenig über eine mögliche Datenstruktur nachgedacht, die möglichst platzsparend ist.
Ich denke mit 4 Bytes, oder genauer 64 Bit, sollte man hinkommen.

Damit kann man mit einem solchen Datensatz die Information "schalte PIN x jeden Montag um 15:35 für 10 Minuten auf HIGH" oder "schalte PIN 5 täglich alle 2 Stunden für 5 Minuten auf LOW" übertragen und speichern.

Die Uhrzeit zur Ventil Öffnung wird sich im Bereich 19- 23 Uhr befinden oder morgens 5-10 Uhr.
Und das dann für ca 2-3 std.

So werde mich jetzt man ran machen, bis später... Oder gleich, mal sehen...

[Reply #43 on:]

So da bin ich schon wieder...
Ich habe mir eben nochmal den ganzen Thread durch gelesen und
bin ja jetzt ein bischen durcheinander gekommen.
Also, ich erläutere nochmal meinen Wunsch und was ich bis jetzt habe...
Wunsch:

* Uhrzeit übergeben (wird sich auf einen Tag beschränken, also Anfang und Ende)
   z.B. 15:30 Uhr
* Wochentag (Montag, Dienstag usw. ; Also kein Datum!)
* länge der Ventil öffnung (30min;45min;60min; max 120min)
* es wird immer nur 1 Ventil zur Zeit geöffnet

Was ich bis jetzt habe:

Die PHP Seite sieht so aus:



Der Code so:

Code:

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Bew&auml;sserung</title>
<link rel="stylesheet" type="text/css" href="ventil.css">
</head>
<body>
<h1><div align="center">Bew&auml;sserung</div></h1>
<?php

$arduino_ip = "192.168.178.211";
$arduino_port = "23";

function arduino_send($ip,$port,$command) {
    $res = fsockopen($ip,$port);
    if($res) {
        fwrite($res,$command);
        $ret =fread($res,10);
        //echo "Ventil = $ret <br>\n";
        //echo "1 = Zu | 0 = Auf <br>\n";
        return $ret;
    } else {
        echo "Fehler, kein kontakt.<br>Kommando konnte nicht abgesetzt werden";
    }
}
// Ventil 1 start

// hier werden 4 byte gesendet ( T ; chr(4) ; chr(0) ; chr($V1) )
// hier kann auch ein 5. byte ?bergeben werden, um welchen Timer es sich handelt
if(isset($_GET['V1'])) {
    $V1 = $_GET['V1'];                      //PinNR.   AUF    Timer1  Ventil1
    arduino_send($arduino_ip,$arduino_port,"T".chr(4).chr(0).chr(0).chr($V1));
}

//if($_GET['V1']) {
//    $V1 = arduino_send($arduino_ip,$arduino_port,"U".chr(4).chr($V1));
// }

if(isset($_GET['V1stop'])) {
    $V1stop = $_GET['V1stop'];
    arduino_send($arduino_ip,$arduino_port,"S".chr(4).chr(1));
}
 else {
    $V1stop = arduino_send($arduino_ip,$arduino_port,"R".chr(4).chr(1));
 }
// Ventil 1 ende
?>
<div align="center">
<table border="1">
<tr>
<td id="V">Ventil1</td>
</tr>
<tr>
<td id="V1"><br>
<form action="">
<select name="Wochentag" class="wotag">
  <option selected value="">Wochen Tag</option>
  <option value="1">Montag</option>
  <option value="2">Dienstag</option>
  <option value="3">Mittwoch</option>
  <option value="4">Donnerstag</option>
  <option value="5">Freitag</option>
  <option value="6">Samstag</option>
  <option value="0">Sonntag</option>
</select><br>
<select name="Uhrzeit" class="std">
 <option selected value="">Uhrzeit</option>
 <option value="16">16 Uhr</option>
 <option value="17">17 Uhr</option>
 <option value="18">18 Uhr</option>
 <option value="19">19 Uhr</option>
 <option value="20">20 Uhr</option>
 <option value="21">21 Uhr</option>
 <option value="22">22 Uhr</option>
 <option value="23">23 Uhr</option>
 <option value="0">0 Uhr</option>
 <option value="1">1 Uhr</option>
 <option value="2">2 Uhr</option>
 <option value="3">3 Uhr</option>
 <option value="4">4 Uhr</option>
 <option value="5">5 Uhr</option>
 <option value="6">6 Uhr</option>
 <option value="7">7 Uhr</option>
 <option value="8">8 Uhr</option>
 <option value="9">9 Uhr</option>
 <option value="10">10 Uhr</option>
 <option value="11">11 Uhr</option>
 <option value="12">12 Uhr</option>
 <option value="13">13 Uhr</option>
 <option value="14">14 Uhr</option>
 <option value="15">15 Uhr</option>
</select>
<select name="Minuten" class="min">
  <option selected value="">Min</option>
  <option value="0">0</option>
  <option value="5">5</option>
  <option value="10">10</option>
  <option value="15">15</option>
  <option value="20">20</option>
  <option value="25">25</option>
  <option value="30">30</option>
  <option value="35">35</option>
  <option value="40">40</option>
  <option value="45">45</option>
  <option value="50">50</option>
  <option value="55">55</option>
</select><br>
<select name="V1" class="timer">
<option selected value="">&nbsp;Timer</option>
<option value="15">15 min</option>
<option value="30">30 min</option>
<option value="45">45 min</option>
<option value="60">60 min</option>
</select>
<input type="checkbox" name="V1stop" value="1"><font size=
"-1">Zu</font>
<p></p>
<div align="center"><input type="submit" name="submit" value=
"Senden"></div>
<p></form>
<?php if($V1stop==1){
  echo "<div id='Zu'>&nbsp;Geschlossen&nbsp;</div>\n";
} else {
  echo "<div id='Auf'>&nbsp;Offen&nbsp;</div>\n";}
?></td>
</tr>
<tr>
<td>
<?php
  $V1 = arduino_send($arduino_ip,$arduino_port,"U".chr(4).chr($V1).chr(0));
  $restzeit = $V1;
if($restzeit!=0){
   echo '<div id="V8">Rest <b>' .gmdate("i:s", $V1). '&nbsp;min</b></div>';
   } else {
   echo "&nbsp;"; }
  ?>
  </td>
</tr>
</table></p>
</body>
</html>

Und der Sketch so:
https://dl.dropbox.com/u/80052077/PHP_Ausgang_schalten.ino

Übergeben tue ich momentan nur folgende Parameter (4 Byte):
* die PinNr.
* Auf oder ZU
* TimerNr.
* VentilNr.

Hinzukommen müsste noch Wochentag und Uhrzeit, oder ? 
Der Wochentag ist bei der RTC, wenn ich mich nicht verlesen habe:
0=Sonntag,1=Montag,2=Dienstag, usw.

Also übergebe ich z.B. die 2 für Dienstag

Code:

                                                    //PinNR.   AUF    Timer1  Ventil1 WoTag
    arduino_send($arduino_ip,$arduino_port,"T".chr(4).chr(0).chr(0).chr($V1).chr(2));

Aber wie die Uhrezeit ?
Ich habe keine Vorstellung wie das Aussehen soll,
weder auf der Arduinoseite noch der PHPseite :-(
Oder ich denke mal wieder zu kompliziert...

[Reply #44 on:]

So, ich habe mal einen Sketch erstellt,
der Kompiliert ohne Fehlermeldung, aber ich weiß leider nicht mehr wie ich die Daten von der PHP Seite an den Arduino übergebe...  
Bzw. in welcher Reihenfolge, habe das irgndwie nicht Kommentiert in meinen Vorigen Sketchen...
Hier der Sketch (Case "T" ist der Bereich):

Code:

#include <SPI.h>
#include <Ethernet.h>
#include <Wire.h>
#include <DS1307new.h>
uint16_t TimeIsSet = 0xaa55;

// MAC und IP Konfiguration
byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0xEE, 0xF3 };
IPAddress ip(192,168,178,211);
IPAddress gateway(192,168,178,1);
IPAddress subnet(255, 255, 255, 0);

// warten auf port 23
EthernetServer server(23);

unsigned long previousMillis = 0;  

#define NUMTIMER 6               // 6 Timer können kommen
int TI;                          // Variable für Timer

// Anschluß für Ventil
int timerpin[NUMTIMER];          // Variable für Ausgangs-Pin

// Wochentag für bewässerung
int pumpday[NUMTIMER];        // Variable für Wochentag

// Uhrzeit für Bewässerung
int pumphour[NUMTIMER];      // Variable für Uhrzeit (Stunde)
int pumpminute[NUMTIMER];   // Variable für Uhrzeit (Minute)
int pumpsecond = 0;              // Variable für SeKunden, die aber nicht übergeben werden

// Bewässerungszeit in Sekunden
int timerlength[NUMTIMER];       // Variable für übergebene Zeit

// Variable um sich die Zeit beim Einschalten der Pumpe zu merken
long timenow = 0;

// *********************************************
// SETUP
// *********************************************
void setup() {
  //Ethernet initialisieren
  Ethernet.begin(mac, ip, gateway, subnet);
  // Server starten
  server.begin();
  // serielle konsole öffnen (debug)
  Serial.begin(9600);
}
  
// *********************************************
// MAIN (LOOP)
// *********************************************
void loop() {
  
  RTC.getTime();
    //prüfen ob eine Sekunde vergangen ist
  if(millis()-previousMillis >= 1000) {
    //aktuelle Zeit merken
    previousMillis = millis();

    //alle timer auswerten
    for(int t=0; t<NUMTIMER;t++) {

      //nur timer beachten, die auch verwendet werden sollen (positive PIN nummer)
      if(timerpin[t] > 0 ){

        //bei aktuellem timer eine sekunde abziehen, wenn "0", dann abgelaufen
        if( --timerlength[t] == 0) {
          //Ausgang umschalten ( HIGH -> LOW oder LOW -> HIGH)
          digitalWrite(timerpin[t],!digitalRead(timerpin[t]));  

          //timer deaktivieren ( timer mit pin "-1" sind inaktiv)
          timerpin[t] = -1;

          //debug
          Serial.print("T Kommando empfangen, Timer ");
          Serial.print(t);
          Serial.println(" abeglaufen.");
        }
      }  
    }
  }

  // auf eine eingehende Verbindung warten
  EthernetClient client = server.available();
  
  if (client) {
  
    char command =client.read();
    byte pinnumber =client.read();
    byte pinvalue =client.read();
    byte returnvalue = 0;
    
  

    //Kommando auswerten
    switch(command) {

    case 'S':
      Serial.print("S Kommando empfangen, setze Pin ");
      Serial.print(pinnumber);
      Serial.print(" auf ");
      Serial.println(pinvalue);
      pinMode(pinnumber,OUTPUT);
      digitalWrite(pinnumber,pinvalue);
     //gesetzten wert auch zurückliefern
      returnvalue=pinvalue;
      break;

    case 'R':
      returnvalue = digitalRead(pinnumber);
      Serial.print("R Kommando empfangen, lese Pin ");
      Serial.print(pinnumber);
      Serial.print(". Wert = ");
      Serial.println(returnvalue);
      break;
      
   case 'U':
      TI = client.read();                     // Timer Nr.
      Serial.print("U Kommando empfangen, lese Timer ");
      Serial.print(TI);
      Serial.print(" Wert = ");
      Serial.println(timerlength[TI] /60);
      client.print(timerlength[TI] /60);
      break;

   case 'T':
     TI = client.read();                     // Timer Nr.
     pumpday[NUMTIMER] = client.read();      // Wochentag
     pumphour[NUMTIMER] = client.read();     // Uhrzeit Stunde
     pumpminute[NUMTIMER] = client.read();   // Uhrzeit Minuten
     timerlength[TI] = client.read();        // zeit für ventil öffnung
     timerpin[TI] = pinnumber;               // zu schaltender Pin
     timerlength[TI] = timerlength[TI] *60;  // die empfangenen sec*60 = min
     pinMode(timerpin[TI],OUTPUT);
    
  // Start Ventil   RTC.dow
  if (int (RTC.dow) == pumpday[NUMTIMER] && int(RTC.hour) == pumphour[NUMTIMER] && int(RTC.minute) == pumpminute[NUMTIMER] && int(RTC.second) == pumpsecond)
  {
    digitalWrite(timerpin[TI],pinvalue);
    timenow = RTC.time2000;
  }
  
  // Stop Ventil
  if (RTC.time2000 - timenow == timerlength[NUMTIMER])
  {
    digitalWrite(timerpin[TI], LOW);
  }
  
     //pinMode(timerpin[TI],OUTPUT);
     //digitalWrite(timerpin[TI],pinvalue);
     returnvalue=pinvalue;                 //gesetzten wert auch zurückliefern
     break;

    default:
      Serial.println("Fehler, unbekanntes Kommando");    
      break;

    }  
    
    // rückantwort senden (1 byte) die "+48" sorgen dafür das der Wert 0 oder 1 als Zeichen "0" oder "1" übertragen werden.
    //das vereinfacht die verarbeitung in php.
    client.write(returnvalue+48);
    
    //übertragung erzwingen
    client.flush();
    
    //10ms delay damit daten sicher gesendet werden.
    delay(10);
    
    //wichtg! client verbindung beenden
    client.stop();
  }
}
  

Der php Teil sieht so aus, aber wie wird der erweitert ?

Code:

                                   Case . PinNr . AUF . Timer1 . Ventil1
arduino_send($arduino_ip,$arduino_port,"T".chr(4).chr(0).chr(0).chr($V1));

Es fehlt :
* Wochentag
* Stunde
* Minute

Hilfe....