1. Schritte mit HS485

Hallo Ernst,

Die Doku von ELV ist recht Mager, und nicht auf dem neusten Stand!

meine Worte.

Einzelne Befehle senden, geht wie Du ja festgestellt hast recht „einfach“.

Frames empfangen, und die empfangenen Werte Variablen zuweisen ist nicht ganz so einfach.

Ich habe zur zeit 13 HS485-Module im Einsatz. Da geht auf dem Bus einiges ab!

Da geht wohl was ab :slight_smile:

Habe ja schon Scriptausschnitte von Dir gesehen, das ist nur was für jemanden der was davon versteht, ich nicht, kann aber nur besser werden.

Ich werde auch weiter machen und sehen was bei raus kommt.

Freue mich auf deine Version :wink:

Hallo Hans-Jörg,

wie schon geschrieben füge ich zur Zeit die Checksumme per Hand ein.

So, jetzt geht es aber richtig los und habe sie mit eingebunden im Script.

Das Ergebniss vom Ausrechnen sieht ja so aus: 174 oder D2C4, das kann man ja so nicht mitsenden. Wie bekomme ich dieses jetzt in das Format
x01\x74.
Zumal er mir wenn ich die CRC16 anhänge ganz wasanderes ausgibt.

Hier mal die ersten Stücke.

<?
/*
*******************************
 IP-SYMCON Event Scripting
*******************************
File     : Send_HS485.ips.php
Trigger  : 
Interval : 
*/


$ComID   = 51003;
$Eingabe = GetValueString("HS485_Ausgang");

//$Interface = "\xFE\x04\x01\xBE\xD2";
//COMPort_SendText(51003, $Interface);

$Startzeichen    = "\xFD";
$HS485_127IO     = "\x00\x00\x18\xEA";
$HS485_S         = "\x00\x00\x10\x98";
$Kontrollzeichen = "\x98";
$Absender        = "\x00\x00\x00\x00";
$Framelaenge     = "\x06";
$Framedaten      = "\x73\x00";
$HS485_127IO_A1  = "\x0C";
$HS485_127IO_A2  = "\x0D";
$HS485_127IO_A3  = "\x0E";
$HS485_127IO_A4  = "\x0F";
$HS485_127IO_A5  = "\x10";
$HS485_127IO_A6  = "\x11";
$HS485_127IO_A7  = "\x12";
$HS485_S_A1      = "\x01";
$HS485_S_A2      = "\x02";
$Ein             = "\x01";
$Aus             = "\x00";
$Toggle          = "\xFF";
//$CRC             = "\x00\x00";
//$Datenframe = $Startzeichen.$HS485_127IO.$Kontrollzeichen.$Absender.$Framelaenge.$Framedaten.$HS485_127IO_A1.$Toggle;

switch($Eingabe)
{
  case 'IOA1t':
  $IOA1t = $Startzeichen.$HS485_127IO.$Kontrollzeichen.$Absender.$Framelaenge.$Framedaten.$HS485_127IO_A7.$Toggle;
  $CRC16 = GetCRC16 ($IOA1t."\x00\x00");

  //$CRC16 = $CRC16("\x", 2 - ($CRC16));
  //$CRC16 = dechex($CRC16);
  //$CRC16 = "\x01\x74";
  $Aktor1 = $IOA1t.$CRC16;
  COMPort_SendText($ComID, $Aktor1);
  echo "Checksum 1: ". sprintf("%X", $CRC16). "
";
  IPS_LogMessage($IPS_SELF, "HS485_Ausgang:  ". $Aktor1);
  break;
}
//$CRC16 = GetCRC16($Datenframe. "\x00\x00");
//$Sendedaten = $CRC16;
//$Aktor1 = "\xFD\x00\x00\x18\xEA\x98\x00\x00\x00\x00\x06\x73\x00\x12\xFF\x01\x74";
//$Aktor1_Zustand = "\xFD\x00\x00\x10\x98\x98\x00\x00\x00\x00\x06\x73\x00\x01\xFF\x3D\x72";

//COMPort_SendText($ComID, $Aktor1);
//COMPort_SendText($ComID, $Aktor1_Zustand);


//echo "Ausgang ". sprintf("%X", $byte)."
";
//IPS_LogMessage($IPS_SELF, "HS485_Ausgang:  ". $Aktor1);

//$daten = GetValueString("HS485_Daten");


//Checksumme berechnen
//$strToSend =  "\xFD\x00\x00\x10\x98\x98\x00\x00\x00\x00\x06\x73\x00\x01\xFF";
//$strToSend = "\xFD\x00\x00\x18\xEA\x98\x00\x00\x00\x00\x06\x73\x00\x12\xFF";
//$strToSend = "\xFE\x04\x01";
//$CRC16 = GetCRC16($strToSend. "\x00\x00"); // ergibt "BED2"
//echo "Checksum 1: ". sprintf("%X", $CRC16). "
";


$strReceived = "\xFD\x00\x00\x00\x00\x19\x00\x00\x18\xEA\x02\xA2\x82";
//$strReceived = "\xfe\x04\x01\xbe\xd2";
$CRC16 = GetCRC16($strReceived); // ergibt 0
echo "Checksum 2: ". sprintf("%X", $CRC16). "
";


function GetCRC16($s)
{
$CRCreg = 0xffff00;
for ($cp=0; $cp<strlen($s); $cp++)
{
  $CRCreg |= ord($s[$cp]);
  for ($bp=0; $bp<8; $bp++)
  {
   $CRCreg <<= 1;
   if ($CRCreg & 0x1000000) $CRCreg ^= 0x100200; // hier ist das Polynom 0x1002 enthalten
   $CRCreg &= 0xffffff;
  }
}
return $CRCreg >> 8;
}


?>

Hallo Rainer,

man kann die Checksumme leicht in einen String umwandeln:

$CRC16str = chr($CRC16>>8). chr($CRC16&0x0f);

Oder etwas ausführlicher:

$CRC16hiByte = $CRC16 >> 8;           // Hi-Byte aus $CRC16 extrahieren
$CRC16loByte = $CRC16 & 0x0f;         // Lo-Byte aus $CRC16 extrahieren
$CRC16chrHi = chr($CRC16hiByte);      // Zahl $CRC16hiByte in Character umwandeln
$CRC16chrLo = chr($CRC16loByte);      // Zahl $CRC16loByte in Character umwandeln
$CRC16str = $CRC16chrHi. $CRC16chrLo; // die Characters zu einem String verketten

Beides führt zum selben Ergebnis.

Gruß
HJH

@HJH: man hat mit ein erfahrungs-person (grrr mein deutsch) zu tun.
Danke dir diese funktion habe ich gebraucht - nur anders gestalltet mit mein M$-DOS Basic kenntniss :slight_smile:

Hallo Hans-Jörg,

Danke, aber das versteh ich jetzt nicht.

Die Checksumme ist 2Byte.
Angenommen die Checksumme = BED2. Um diese mitsenden zukönnen brauch ich aber dieses Format \xBE\xD2.
Folglich muss ich BED2 ersteinmal splitten in BE und D2 und dann jeweils ein \x vorstellen.
Dieses \xBE\xD2 wird dann an den Sendebefehl angehängt.

Hallo Hans-Jörg,

zuerst werden die zu sendenden Daten als Hexstring zusammengesetzt.

z.B.:

$Hexdaten =  $Ziel.$Kontrollzeichen.$Absender.$Datenlaenge.$Befehl.$Sensor.$Aktor.$Event;
$Hex_Datensatz = "fd".$Hex_Datensatz; // Startzeichen "fd" davor setzen
// Originaldaten von Hex in ASCII-Format umwandeln
$Sendedaten = hex2asc("fd".$Hexdaten);
$Checksum = hex2asc("0000"); // Platzhalter Checksumme = 0000
// Checksumme errechnen
$Checksum = GetCRC16($Sendedaten.$Checksum);
// Checksumme von Integer in Hex umwandeln
$Checksum = sprintf("%x", $Checksum);
$Checksum = str_repeat("0", 4 - strlen($Checksum)).$Checksum; // führende 0 einfügen
// Checksumme von Hex in ASCII umwandeln
$Checksum = hex2asc($Checksum);
   
// Sendedaten von Hex in ASCII-Format umwandeln
$Sendedaten = hex2asc($Hex_Datensatz);

// Checksumme an Sendestring anhängen und übergeben
SetValueString("HS485_Sendedaten", $Sendedaten.$Checksum);
// Funktion zum Umwandeln eines Hexwertes in einen ASCII-String
function hex2asc($hex)
{
   $str ="";
   $str1 = "";
   for($i=0;$i<strlen($hex);$i+=2)    // $i+=2
   {
      $str1 = hexdec(substr($hex,$i,2));  // Umwandlung von Hex nach Dezimal
      $str .= chr($str1); // Umwandlung von Dezimal nach ASCII
   }
   return $str;
}

Grundlage zum Errechnen der Checksum ist Deine Funktion GetCRC16() :

// Funktion zum errechnen der Checksumme
function GetCRC16($s)
{
$CRCreg = 0xffff00;
for ($cp=0; $cp<strlen($s); $cp++)
{
   $CRCreg |= ord($s[$cp]);
   for ($bp=0; $bp<8; $bp++)
   {
      $CRCreg <<= 1;
      if ($CRCreg & 0x1000000) $CRCreg ^= 0x100200; // hier ist das Polynom 0x1002 enthalten
      $CRCreg &= 0xffffff;
   }
}
 return $CRCreg >> 8;
}

Hallo Rainer, hallo Ernst,

PHP ist, wie viele andere Programmiersprachen auch, eine freundliche Programmiersprache. Sie erlaubt es dem Programmierer Zahlen in verschiedenen Repräsentationen zu verwenden.

Folgende Zahlen sind absolut identisch:
$CRC16 = 48850;
$CRC16 = 0xBED2;

In beiden Fällen besitzt $CRC16 exakt den selben Wert.
Es besteht also nicht der geringste Grund erst umständlich irgendwelche Umwandlungen vornehmen zu müssen.

Daraus folgt:
Das HiBYte von 48850 ist identisch mit dem HiByte von 0xBED2, nämlich 190 (dec) bzw. 0xBE (hex).
Das LoBYte von 48850 ist identisch mit dem LoByte von 0xBED2, nämlich 210 (dec) bzw. 0xD2 (hex).

Das unsägliche „Gefummel“ mit hex2asc(…), hexdec(…), sprintf(…) und str_repeat(…) ist absolut überflüssig und ist lediglich ein Zeichen dafür, dass hier die verschiedenen Darstellungsweisen von Zahlen nicht verstanden wurde.

Da der Datentyp Character nichts anderes ist als ein Byte, kann man sich einen String als die Aneinadereihung von Bytes denken. Wenn also die Zahl 48850 als String ausgegeben werden soll, wird diese in Hi- und LoByte aufgeteilt und als Folge von zwei Bytes übertragen. Damit PHP unsere Bytes nicht in lesbare ASCII-Zeichen wandelt, müssen wir ihm durch die Funktion chr(…) mitteilen, dass es diese Bytes bereits als Character betrachten soll und sie also so belassen soll, wie sie sind.

In meinem vorher genannten Beispiel ist $CRC16str bereits die String-Variante der Integer Checksumme $CRC16.

Dass wir in der String-Darstellung manchmal die hexadezimale Schreibweise ("\xBE\xD2") bevorzugen liegt daran, dass man damit eben alle 256 Bitkombinationen eines Bytes darstellen kann. Mit ASCII-Zeichen ist das eben nicht möglich, da einige davon nicht darstellbar sind, wie z.B. Wagenrücklauf (CR=13=0x0D=ord("\x0D")) oder Zeilenvorschub (LF=10=0x0A=ord("\x0A")).

Gruß
HJH

Hallo Hans-Jörg,

Erst mal Vielen Dank für die ausführliche Erklärung.

Werde sehen, wie weit ich komme.

Hallo Jungs,

so manchmal zweifle ich ja an mir selber. Habe den Fehler gefunden.

$CRC16str = chr($CRC16>>8). chr($CRC16&0x0f);

muss so sein

$CRC16str = chr($CRC16>>8). chr($CRC16&0xff);

Das ein Aktor schaltete war purer Zufall :stuck_out_tongue:

Nun geht es einwandfrei.

So, hier gibt es dann auch mal das fertige Script zum Senden.

Schaltzustände usw. werden noch nicht ausgewertet. Dauert noch ein bisschen.
Ich hoffe der ein oder andere kann was damit anfangen, vorerst zumindest.

<?
/*
*******************************
 IP-SYMCON Event Scripting
*******************************
File     : Send_HS485.ips.php
Trigger  : OnUpdate HS485_Ausgang


**********************************************************************************************
* Schalten der Ausgänge des HS485 Bussystem. Funktioniert nur mit HS485/S und HS485/127/IO   *
* Die Moduladressen müssen angepasst werden und eventuell die Schaltbefehle. Ein/Aus.        *
* Toggle ist angegeben.                                                                      *
* Zeitgesteuerte Abläufe(Treppenhaus,Timer) kann man in der Software von ELV einstellen oder *
* auch über Scripte selbst steuern.                                                          *
**********************************************************************************************
*/


$ComID   = 51003;                              // Comport ID muss angepasst werden //
$Eingabe = GetValueString("HS485_Ausgang");    // Triggervariable //

//$Interface = "\xFE\x04\x01\xBE\xD2";         // Interface testen //
//COMPort_SendText($ComID, $Interface);

$Startzeichen    = "\xFD";                     // Startzeichen FD Vorgabe
$HS485_127IO     = "\x00\x00\x18\xEA";         // Moduladresse muss angepasst werden
$HS485_S         = "\x00\x00\x10\x98";         // Schalteradresse muss angepasst werden
$Kontrollzeichen = "\x98";                     // Kontrollzeichen 98 Vorgabe
$Absender        = "\x00\x00\x00\x00";         // Absenderadresse vom PC immer 00000000
$Framelaenge     = "\x06";                     // Framelaenge ergibt sich aus Befehl,Sensoreingang(vom PC immer 00),Aktornummer und Event(Ein,Aus,Toggle)
$Framedaten      = "\x73\x00";                 // Framedaten hier Befehl "s" Aktor setzen und Sensoreingang "00"
$HS485_127IO_A1  = "\x0C";                     // Modul Ausgang 1-7
$HS485_127IO_A2  = "\x0D";
$HS485_127IO_A3  = "\x0E";
$HS485_127IO_A4  = "\x0F";
$HS485_127IO_A5  = "\x10";
$HS485_127IO_A6  = "\x11";
$HS485_127IO_A7  = "\x12";
$HS485_S_A1      = "\x00";                      // Schalterausgang 1 und 2
$HS485_S_A2      = "\x01";
$Ein             = "\x01";                      // Event, Ein, Aus, Toggle
$Aus             = "\x00";
$Toggle          = "\xFF";
//$CRC             = "\x00\x00";

// Schalten der Ausgänge Modul HS485 127 IO
switch($Eingabe)
{
  case 'IOA1t':
  $IOA1t = $Startzeichen.$HS485_127IO.$Kontrollzeichen.$Absender.$Framelaenge.$Framedaten.$HS485_127IO_A1.$Toggle;  // Datenframe
  $CRC16 = GetCRC16 ($IOA1t."\x00\x00");           // Checksumme berechnen
  $CRC16str = chr($CRC16>>8). chr($CRC16&0xff);    // Hi-Lo-Byte der Checksumme extrahieren
  $Aktor1 = $IOA1t.$CRC16str;                      // Checksumme an Datenframe übergeben
  COMPort_SendText($ComID, $Aktor1);               // Datenframe über Comport senden
  SetValueString("HS485_Ausgang","");              // Variable leeren
  break;
  
  case 'IOA2t':
  $IOA2t = $Startzeichen.$HS485_127IO.$Kontrollzeichen.$Absender.$Framelaenge.$Framedaten.$HS485_127IO_A2.$Toggle;
  $CRC16 = GetCRC16 ($IOA2t."\x00\x00");
  $CRC16str = chr($CRC16>>8). chr($CRC16&0xff);
  $Aktor2 = $IOA2t.$CRC16str;
  COMPort_SendText($ComID, $Aktor2);
  SetValueString("HS485_Ausgang","");
  break;
  
  case 'IOA3t':
  $IOA3t = $Startzeichen.$HS485_127IO.$Kontrollzeichen.$Absender.$Framelaenge.$Framedaten.$HS485_127IO_A3.$Toggle;
  $CRC16 = GetCRC16 ($IOA3t."\x00\x00");
  $CRC16str = chr($CRC16>>8). chr($CRC16&0xff);
  $Aktor3 = $IOA3t.$CRC16str;
  COMPort_SendText($ComID, $Aktor3);
  SetValueString("HS485_Ausgang","");
  break;
  
  case 'IOA4t':
  $IOA4t = $Startzeichen.$HS485_127IO.$Kontrollzeichen.$Absender.$Framelaenge.$Framedaten.$HS485_127IO_A4.$Toggle;
  $CRC16 = GetCRC16 ($IOA4t."\x00\x00");
  $CRC16str = chr($CRC16>>8). chr($CRC16&0xff);
  $Aktor4 = $IOA4t.$CRC16str;
  COMPort_SendText($ComID, $Aktor4);
  SetValueString("HS485_Ausgang","");
  break;
  
  case 'IOA5t':
  $IOA5t = $Startzeichen.$HS485_127IO.$Kontrollzeichen.$Absender.$Framelaenge.$Framedaten.$HS485_127IO_A5.$Toggle;
  $CRC16 = GetCRC16 ($IOA5t."\x00\x00");
  $CRC16str = chr($CRC16>>8). chr($CRC16&0xff);
  $Aktor5 = $IOA5t.$CRC16str;
  COMPort_SendText($ComID, $Aktor5);
  SetValueString("HS485_Ausgang","");
  break;
  
  case 'IOA6t':
  $IOA6t = $Startzeichen.$HS485_127IO.$Kontrollzeichen.$Absender.$Framelaenge.$Framedaten.$HS485_127IO_A6.$Toggle;
  $CRC16 = GetCRC16 ($IOA6t."\x00\x00");
  $CRC16str = chr($CRC16>>8). chr($CRC16&0xff);
  $Aktor6 = $IOA6t.$CRC16str;
  COMPort_SendText($ComID, $Aktor6);
  SetValueString("HS485_Ausgang","");
  IPS_LogMessage($IPS_SELF, "HS485_IOAa6:  ". $Aktor6);
  break;
  
  case 'IOA7t':
  $IOA7t = $Startzeichen.$HS485_127IO.$Kontrollzeichen.$Absender.$Framelaenge.$Framedaten.$HS485_127IO_A7.$Toggle;
  $CRC16 = GetCRC16 ($IOA7t."\x00\x00");
  $CRC16str = chr($CRC16>>8). chr($CRC16&0xff);
  $Aktor7 = $IOA7t.$CRC16str;
  COMPort_SendText($ComID, $Aktor7);
  SetValueString("HS485_Ausgang","");
  //IPS_LogMessage($IPS_SELF, "HS485_IOAa7:  ". $Aktor7);
  break;

// Schalten der Ausgänge des Schalters HS485 S
  case 'SA1t':
  $SA1t = $Startzeichen.$HS485_S.$Kontrollzeichen.$Absender.$Framelaenge.$Framedaten.$HS485_S_A1.$Toggle;
  $CRC16 = GetCRC16 ($SA1t."\x00\x00");
  $CRC16str = chr($CRC16>>8). chr($CRC16&0xff);
  $Aktor1 = $SA1t.$CRC16str;
  COMPort_SendText($ComID, $Aktor1);
  SetValueString("HS485_Ausgang","");
  //IPS_LogMessage($IPS_SELF, "HS485_Sa1:  ". $Aktor1);
  break;
  
  case 'SA2t':
  $SA2t = $Startzeichen.$HS485_S.$Kontrollzeichen.$Absender.$Framelaenge.$Framedaten.$HS485_S_A2.$Toggle;
  $CRC16 = GetCRC16 ($SA2t."\x00\x00");
  $CRC16str = chr($CRC16>>8). chr($CRC16&0xff);
  $Aktor2 = $SA2t.$CRC16str;
  COMPort_SendText($ComID, $Aktor2);
  SetValueString("HS485_Ausgang","");
  //IPS_LogMessage($IPS_SELF, "HS485_Sa2:  ". $Aktor2);
  break;
}

//Checksumme berechnen

function GetCRC16($s)
{
$CRCreg = 0xffff00;
for ($cp=0; $cp<strlen($s); $cp++)
{
  $CRCreg |= ord($s[$cp]);
  for ($bp=0; $bp<8; $bp++)
  {
   $CRCreg <<= 1;
   if ($CRCreg & 0x1000000) $CRCreg ^= 0x100200; // hier ist das Polynom 0x1002 enthalten
   $CRCreg &= 0xffffff;
  }
}
return $CRCreg >> 8;
}


?>

Hallo Rainer,

Du hast natürlich Recht, da hatte sich ein Schreibfehler bei mir eingeschlichen (0x0f stat 0xff).

Aber ein bischen Arbeit muss ich Dir ja auch noch lassen. :smiley: :smiley:

Hier noch eine vollständige und universell einsetztbare CRC16-Funktion:
Bei dieser Funktion kann man sowohl den Startwert ($CRCinit) als auch das Polynom ($CRCpoly) beliebig vorgeben.

function GetCRC16($s)
{
 $CRCinit = 0xffff; // Startwert
 $CRCpoly = 0x1002; // Polynom

 $CRCreg = $CRCinit << 8;
 $PLYreg = $CRCpoly << 8;
 for ($cp=0; $cp<strlen($s); $cp++)
 {
  $CRCreg |= ord($s[$cp]);
  for ($bp=0; $bp<8; $bp++)
  {
   $CRCreg <<= 1;
   if ($CRCreg & 0x1000000) $CRCreg ^= $PLYreg;
   $CRCreg &= 0xffffff;
  }
 }
 return $CRCreg >> 8;
}

Gruß
HJH

Hallo Ernst,

mittlerweile kann ich die Eingänge des IO auch nachvollziehen.

Du hast geschrieben unterschiedliche Länge des Datenframes, kann ich auch nachvollziehen.
Es ist aber so, das ein Befehl immer mit „FD“ beginnt, also muss man immer von „FD bis Checksumme“ die Daten berechnen.
So wie ich das im Moment sehe, String nach Ende der Checksumme abschneiden ob er dann 15 oder 20 Byte lang ist, ist egal. Dann von hinten nach vorne extrahieren oder umgekehrt.:confused:
Zumal die Broadcastadresse ziemlich uninteressant ist für die Kommunikation mit dem PC.

Hallo Rainer,

von vorne nach hinten, da der einzige feste Bezugspunkt das Zeichen „FD“ ist.
Die Länge des Frames errechnet sich aus dem Feld „Framelänge“ + 11 (felder FD … Framelänge)

Ausnahme: Der Frame enthält ein Steuerzeichen (FC, FD, FE).

Diese Steuerzeichen wird folgendermassen ersetzt:

Vor das Steuerzeichen wird das Escapezeichen „FC“ gesetzt, gefolgt von dem eigentlichen Steuerzeichen, dessen höchstwertiges Bit gelöscht wird.

z.B: Steuerzeichen „FD“ gesendet wird „FC 7D“

„7D“ erhälst Du mit " 0xFD & 0x7f "

Hallo,

seit ein paar Tagen schlage auch ich mich mit dem Thema „Checksumme“ herum. Zum Thema CRC16 gibt es zwar einiges, aber nichts hat mich weitergebracht. Jedenfalls bekomme ich nicht die richtige Checksumme heraus.
Die theoretische Ausführung von HJH ist zwar gut, hat mich aber leider auch noch nicht zum Ziel gebracht. Programmtechnisch habe ich bisher nichts in PHP oder Pearl gemacht, und C++ ist schon einige Jahre her.
In den Beispielscripten zum Thema Checksumme kann ich deshalb eine Zeile nicht nachvollziehen.

Problemzeile: $CRCreg |= ord($s[$cp]);

$CRCreg = Ausgangsvariabel
$s = Zeihenfolge von der die Checksumme erstellt werden soll
$cp = Position des Zeichens welches dran ist

|= ord ???

Kann mir bitte jemand erklären, was „|= ord“ bewirkt.

VG Tobias

$CRCreg |= ord($s[$cp]);

das ist eine kleine Anleihe von „C“.Es heisst, die Variable wird Oder-Verknüpft mit dem Wert, den die ord-Funktion liefert und das Ergebnis gleich wieder der Variable zugewiesen ist (siehe Operator-Manual).
Andere Schreibweise:

$CRCreg=$CRCreg | ord($s[$cp]); 

Tommi

Hallo Tommi,

vielen Dank für die schnelle Antwort. Jetzt hat es endlich geklappt.:slight_smile:

VG Tobias

Hallo zusammen,

ich verfolge schon geraume Zeit die Diskussion(en) hier im Forum über die Unterstützung der HS485.

Ich habe einen Altbau zuerst renoviert, und danach doch saniert …:wink:

In diesem ZUge habe ich die HS485 eingebaut. Leider fehlen mir Funktionaliäten wir Zeit gesteuerte oder „intelligente“ Aktionen.

Bevor ich mich nun selbst an einem Stück Software versuche, wollte ich Euch bitten, mir eine kurze Zusammenfassung der Anbindung an IP Symcon zu geben.

  1. Was kann ich über die Schnittstelle (Danke an den Committer) die Ihr hier bespricht machen?
  2. Kann ich die HS485 über IP Symcon Programmieren oder nur einzelne Module schalten?
  3. Welche Hardware Voraussetzungen braucht man für IP Symcon? Gibt es getrennte Server / Client Komponenten oder greift man einfach per Browser zu?

Ich danke Euch im Voraus für die Anworten,
Ata.

Hallo Ata und willkommen im Forum…

Zu 1: Kann ich dir nicht viel sagen da ich so ein System nicht selbst besitze. Aber ich denke es geht darum die Module direkt zu schalten.

Zu 2: Eine feste Programmierung der Komponenten ist bei ELV eigentlich nie über die Schnittstellen möglich. Aber auch das kann ich fürs HS485 nicht mit letzter Gewissheit sagen.

Zu 3: IPS ist nicht sehr hardwarehungrig. Ich habe mit einem 450er Prozessor angefangen. Es gibt einen Server, der mit einem Client bedient werden kann (der Designer) und es gibt einen Webserver, der mit dem Browser angesprochen werden kann. Dabei hast du die Wahl zwischen zwei sehr guten fertigen Oberflächen (im Prinzip Webseiten-Sammlungen) oder die Möglichkeit dir was eigenes zu bauen. Dieser kann im eigenen Netzwerk UND/ODER übers Internet angesprochen werden. Alles kein Problem. Du kannst auch beide Verfahren (Webserver und Client) mischen und nach belieben kombinieren.

Gruß,

Toni

Hallo ata,

Zu 1 + 2:
Als Hardwareschnittstelle wird das HS485 PC-Interface benötigt. Hierüber kann man Module schalten und deren Schaltzustand bzw. Messwerte abfragen. Eine Programmierung der HS485 Module ist zwar auf diesem Wege theoretisch auch möglich, doch das mit dem Interface gelieferte Programm „HS485 Konfiguration“ dürfte hierfür ausreichend sein. (Warum das Rad neu erfinden ?)

Hallo und Danke für die Antworten,

hab mir gerade die Lizenz gekauft damit ich endlich loslegen kann.

Da ich mich natuerlich mit IP Symcon noch nicht auskenne, könnte Ihr mir einen Tip geben, wo ich dieses PHP Script weiter vorne hinlegen muss?

Ich weiss, meine Fragen gehören wahrschienlich nihct in diesen Thread aber ich möcht schnellsmöglich anfangen. :p:p

Muss ansonsten noch etwas in IP Symcon konfigurieren, damit die „Schnittstelle“ steht?

Ata.