CUL per Telnet/Putty ansprechen funktioniert nicht

[WhiteLion]

Moin Leute,

ich bin neu hier und in punkto Hausautomatisierung blutiger Anfänger.
Nachdem ich das Tutorial tw gelesen habe, entschied ich mich erstmal (zum testen)
nur das Nötigste an Hardware zur Steuerung meiner Rollos von Somfy zu kaufen.
Deswegen hab ich mir also einen CUL mit 868MHz von Busware bestellt.
Als C# Entwickler möchte ich natürlich möglichst auch einiges unter Windows probieren
und auch erstmal die Anschaffung vom Raspby verschieben.
Meinen CUL hab ich mit der CUL_V3.hex Firmware geflasht und frage mich jetzt wie es
weiter geht.... Ich hab gelesen, dass man ihn nun per Telnet auf Port 2323 ansprechen
können soll... deswegen hab ich versucht per Putty auf diesem Port zu connecten.
Das hat aber leider nicht funktioniert und ich weiss nicht genau wie es weiter gehen kann.
ich stelle mir das im Moment so vor, dass ich dann per per Telnet irgendwelche Befehle
abfeuern kann die den CUL dazu bewegen mir empfangene Signale in hexa auszugeben
oder sachen zu versehen .... Evtl könnt Ihr mir bei meinen Vorhaben helfen ?

[Hacky]

Hi, ich hab nun auch ein wenig mit FHEM rumprobiert, bin aber leider absolut kein Fan der Pyhton ide.
Ich werde mich nun auch mal an der Geschichte C# probieren und versuchen den Cul per C# Telnet anzusprechen.
Dein Post ist ja nun ein paar Tage her, vllt hast du ja einen Ansatz gefunden ? Das Rad muss ja nicht neu erfunden werden

Ansonsten habe ich das hier gefunden aus einem GitHub-Project: https://github.com/RussPAll/FhemDotNet

TelnetConnection class:

Was ich nicht weiß, ob er auch den CUL verwendet oder die TelnetConnection sich mit irgendetwas anderem verbindet ...

Code Auswählen Erweitern


using System.Text;
using System.Net.Sockets;
using FhemDotNet.CrossCutting;
using FhemDotNet.Repository.Interfaces;

namespace FhemDotNet.Repository
{
    enum Verbs
    {
        Will = 251,
        Wont = 252,
        Do = 253,
        Dont = 254,
        Iac = 255
    }

    enum Options
    {
        Sga = 3
    }

    public class TelnetConnection : ITelnetConnection
    {
        readonly TcpClient _tcpSocket;

        const int TimeOutMs = 100;

        public TelnetConnection(string hostname, int portNo)
        {
            Validation.NotNullOrEmpty(() => hostname);
            _tcpSocket = new TcpClient(hostname, portNo);
        }

        ~TelnetConnection()
        {
            if (_tcpSocket != null && IsConnected)
                _tcpSocket.Close();
        }

        public void WriteLine(string cmd)
        {
            Write(cmd + "\n");
        }

        /// <exception cref="System.ArgumentNullException">cmd is not specified</exception>
        public void Write(string cmd)
        {
            if (!IsConnected) return;

            byte[] buf = Encoding.ASCII.GetBytes(cmd.Replace("\0xFF", "\0xFF\0xFF"));
            _tcpSocket.GetStream().Write(buf, 0, buf.Length);
        }

        /// <exception cref="System.ArgumentOutOfRangeException">Sleep timeout const is set to an invalid value</exception>
        /// <exception cref="System.ObjectDisposedException">The System.Net.Sockets.Socket has been closed.</exception>
        /// <exception cref="System.Net.Sockets.SocketException">An error occurred when attempting to access the socket. See the Remarks section for more information.</exception>
        public string Read()
        {
            if (!IsConnected) return null;

            var sb = new StringBuilder();
            do
            {
                ParseTelnet(sb);
                System.Threading.Thread.Sleep(TimeOutMs);
            } while (_tcpSocket.Available > 0);
            return sb.ToString();
        }

        public bool IsConnected
        {
            get { return _tcpSocket.Connected; }
        }

        void ParseTelnet(StringBuilder sb)
        {
            while (_tcpSocket.Available > 0)
            {
                int input = _tcpSocket.GetStream().ReadByte();
                switch (input)
                {
                    case -1:
                        break;
                    case (int)Verbs.Iac:
                        // interpret as command
                        int inputverb = _tcpSocket.GetStream().ReadByte();
                        if (inputverb == -1) break;
                        switch (inputverb)
                        {
                            case (int)Verbs.Iac:
                                //literal Iac = 255 escaped, so append char 255 to string
                                sb.Append(inputverb);
                                break;
                            case (int)Verbs.Do:
                            case (int)Verbs.Dont:
                            case (int)Verbs.Will:
                            case (int)Verbs.Wont:
                                // reply to all commands with "Wont", unless it is Sga (suppres go ahead)
                                int inputoption = _tcpSocket.GetStream().ReadByte();
                                if (inputoption == -1) break;
                                _tcpSocket.GetStream().WriteByte((byte)Verbs.Iac);
                                if (inputoption == (int)Options.Sga)
                                    _tcpSocket.GetStream().WriteByte(inputverb == (int)Verbs.Do ? (byte)Verbs.Will : (byte)Verbs.Do);
                                else
                                    _tcpSocket.GetStream().WriteByte(inputverb == (int)Verbs.Do ? (byte)Verbs.Wont : (byte)Verbs.Dont);
                                _tcpSocket.GetStream().WriteByte((byte)inputoption);
                                break;
                        }
                        break;
                    default:
                        sb.Append((char)input);
                        break;
                }
            }
        }
    }
}



[WhiteLion]

Also ohne jetzt das Vorhaben total über den Haufen geworfen zu haben....
Ich hab mir einen Raspy 2 geholt und letztendlich doch erstmal FHEM installiert.
Allerdings werde ich mich später (wenn ich mich besser mit der Materie vertraut gemacht habe)
weiter damit beschäftigen.
Nun war ich aber bereits einen Schritt weiter und hatte es zumindest geschafft den CUL
per COM - Port einzubinden .... Das ganz geht eigentlich relativ leicht.
Du schaust dir im Gerätemanager an, welchen COM-Port der CUL benutzt und machst das ganze
über die entsprechenden C# Libs .... Ich habe einfach das hier verwendet:
http://www.codeproject.com/Articles/678025/Serial-Comms-in-Csharp-for-Beginners

Allerdings müsste man den CUL dann wohl recht ROH füttern... Will heissen die Ganzen Protokolle
für die Kommunikation stehen einem nicht zur Verfügung, die muss man sich dann am besten aus
der FHEM abkupfern. Genauso wie die Befehle die der CUL so verarbeitet .... da bin ich nicht so wirklich
durchgestiegen.... sind ja auch nur bits und bytes ....
mal gucken ob ich jetzt die Raspy mit FHEM und CUL wenigstens einfach und ohne Umstände per
C# und Telnet steuern kann ... auch wenn das wieder ein stück weit sinnlos ist....