Weichendecoder mit Servo

Lorenzo
Beiträge: 34
Registriert: 20.04.2019, 19:24
Hat sich bedankt: 1 Mal
Danksagung erhalten: 1 Mal

Weichendecoder mit Servo

Beitrag von Lorenzo » 07.06.2019, 10:52

Hallo zusammen,

wie bereits an anderer Stelle bemerkt, möchte ich das Framework für meinen Weichendecoder etwas erweitern. Generell plane ich Folgendes:
  • Verlangsamen der Servo Geschwindigkeit für natürlicheres Weichen stellen
  • Einlesen Meldekontakt bevor Weiche aufgeschnitten wird zum automatischen Stellen der Weiche
  • Rückmeldung der Weichenstellung über MQTT
  • Stellen der Weiche über MQTT
Für den ersten Punkt habe ich bereits Anpassungen vorgenommen. Meine Schwierigkeit hierbei ist, dass ich mich mit cpp und Klassen leider nicht auskenne. Ich komme noch aus der Assembler und C Welt. So habe ich z.B. keinen einfachen Weg gefunden, in unterschiedlichen Klassen auf einen gemeinsamen Wert zuzugreifen. Speziell für der ersten Punkt heißt das, dass ich einen Verzögerungswert in ms in der config.json angebe, der dann überall zur Verfügung stehen soll.

Später kommt noch ein weiterer Wert dazu. Ich möchte die Weichenadresse gern über einen DIP switch einstellen und über einen MCP23017 einlesen. Dieser Wert soll dann nicht nur die Weichenadresse darstellen, sondern auch einen Offset auf eine feste IP Adresse in meinem WLAN Netz, in dem auch ein MQTT Server (RasPi) hängt. Aber eins nach dem anderen.

Vorerst habe ich mir mit einer globalen Variablen geholfen. Das funktioniert auch, aber ich habe mich etwas in cpp eingelesen und dort gesehen, dass globale Variablen nicht mehr das Mittel der Wahl sind. Da fehlt es mir noch an Hintergrundwissen.

Ich möchte euch hier schon einmal die von mir gemachten Änderungen (auf Basis der Version V1.2.2) mitteilen. Vielleicht kann ja der ein oder andere davon profitieren oder mir noch Tipps geben.
  • in config.h habe ich eine globale Variable für die Verzögerung deklariert

Code: Alles auswählen

extern unsigned int moveDelay;
  • in config.cpp wird diese Variable initialisiert

Code: Alles auswählen

extern unsigned int moveDelay = 0;      // delay for servo movement [ms/degree]
unter "turnout2value" in parseIn habe ich das Einlesen der Verzögerung aus config.json ergänzt:

Code: Alles auswählen

moveDelay = parser->getValueByKey(idx, "delay").toInt();
Serial.println("Turnout2Value delay: " + String(moveDelay) + " [ms/degree]");
  • in ActionServo.h wurden folgende Variablen unter private hinzugefügt:

Code: Alles auswählen

unsigned int newPosition;
unsigned int actPosition = -1;
  • dazu die Ergänzungen in ActionServo.cpp:

Code: Alles auswählen

#include "config.h"

Code: Alles auswählen

int ActionServo::loop() {
	if (lastcommand == 0) {
		return 50;
	}
	// next Servo move after xx ms (moveDelay)
	if (millis() > lastcommand + moveDelay) {
		if (actPosition != -1) {
			if (actPosition > newPosition) {
				myservo.write(--actPosition);
				lastcommand = millis();
			} else if (actPosition < newPosition) {
				myservo.write(actPosition++);
				lastcommand = millis();
			}
		}
	}

	// Autodetach after 2 sec
//	if (millis() > lastcommand + 2000) {
	// Autodetach after newPosition reached + 10ms or after 2s (moveDelay = 0)
    if (millis() > lastcommand + (moveDelay == 0 ? 2000 : 10) && actPosition == newPosition) {
		lastcommand = 0;
		detach();
		return 2000;
	}
	return 5;
}
sowie

Code: Alles auswählen

void ActionServo::setSettings(String key, String value) {
	unsigned int status = value.toInt();
    Logger::getInstance()->addToLog(
            "Servo Value: " + value);
	if (status == -1) {
		detach();
	} else {
        newPosition = status;
        if (actPosition == -1 || moveDelay == 0) {
            actPosition = status;
            myservo.write(actPosition);
        }
        attach();
        lastcommand = millis() + moveDelay;
	}
}
Damit kann in der config.json der Verzögerungswert delay in ms/Grad eingestellt werden:

Code: Alles auswählen

	"in":[
		{
			"m": "turnout2value",
			"addr": "1",
			"delay": "25",
			"out": [ "S1" ],
			"turnout2value": { "0": "55", "1": "120"}
		}	
	],
Bei mir funktioniert das soweit zufriedenstellend. Anmerkungen oder Verbesserungen werden gern gesehen.

Sobald ich weiter in dem Thema bin, werde ich das Neue wieder hier einstellen.

Beste Grüße
Lorenzo
Zuletzt geändert von Lorenzo am 07.06.2019, 13:27, insgesamt 1-mal geändert.

Lorenzo
Beiträge: 34
Registriert: 20.04.2019, 19:24
Hat sich bedankt: 1 Mal
Danksagung erhalten: 1 Mal

Re: Weichendecoder mit Servo

Beitrag von Lorenzo » 07.06.2019, 11:07

Hier noch meine geplante Schaltung

Weichendecoder Schaltung.png
Weichendecoder Schaltung.png (53.69 KiB) 8423 mal betrachtet

Das Board kommt in ein kleines Gehäuse. Die schmaleren Seitenteile links und rechts werden von der Platine getrennt und hochkannt eingebaut. Damit ergibt sich ein kompaktes Layout. Die Platine ist allerdings beidseitig bestückt. Lediglich auf der Oberseite ist ein Bereich für den Servo freigehalten.

Weichendecoder Layout.png
Weichendecoder Layout.png (28.35 KiB) 8423 mal betrachtet
Ich hoffe, dass die ersten Platinenmuster bald kommen und ich dann weitere Bilder einstellen kann. Aber erfahrungsgemäß dauert das aus China einige Wochen.

Beste Grüße

little.yoda
Site Admin
Beiträge: 882
Registriert: 14.09.2018, 19:05
Hat sich bedankt: 33 Mal
Danksagung erhalten: 143 Mal

Re: Weichendecoder mit Servo

Beitrag von little.yoda » 07.06.2019, 21:10

Hi

interessantes Projekt.

Ja, wenn man ASM und C gewöhnt ist, dann ist C++ schon eine Umgewöhnung.
Ehrlich gesagt nutze ich aber nur ein Bruchteil der C++ Funktionalität. Im wesentlichen nutze ich C++ einfach zur besseren Strukturierung und zur Abschottung der einzelnen Module.

Zu deinen Fragen:

Geschwindigkeitsregelung Servo
Da du die Information ja nur in der Klasse ActionServo benötigst, würde ich das delay-Statement aus dem turnout2value Bereich des Config-Files herausziehen und ich den Servo-Bereich verschieben. Anschließend erweiterst du am besten den Konstruktor der ActionServo-Klasse, um den Parameter für die Geschwindigkeit

Code: Alles auswählen

ActionServo::ActionServo(int pin, int delay)
Im Konstruktor weist du dann den Wert einer privaten Variable zu. Also

Code: Alles auswählen

this->delay = delay


Und in der Klasse config.cpp , änderst du dann den Aufruf des Konstruktor

Code: Alles auswählen

			int gpioservo = GPIOobj.string2gpio(parser->getValueByKey(idx, "gpio"));
			int delay= parser->getValueByKey(idx, "delay").toInt();
			ActionServo* a = new ActionServo(gpioservo,delay);
Irgendwann muss dann noch eine Behandlung für den Fall rein, das delay nicht im Config-File enthalten ist. Darum kümmere ich mich aber gerne, wenn ich deine Änderungen übernehme.

Dip-Schalter
Den Zustand von PINs kannst du folgendermaßen auslesen:

Pin* pin = new Pin("E0A0"); // erster MCP und dann Pin A0
int ret = GPIOobj.digitalRead(pin);


Ich habe aber noch keine gute Idee, wie man deine Anforderung (Weichenaddresse über DIP-Schalter) sauber implementiert.
Unsauber =>
config.cpp, Anweisung

Code: Alles auswählen

int addr = parser->getValueByKey(idx, "addr").toInt();
im turnout2vaule z.B. durch folgendes Ersetzen:

Code: Alles auswählen

Pin* pin0 = new Pin("E0A0"); // erster MCP und dann Pin A0
Pin* pin1 = new Pin("E0A1");
Pin* pin2 = new Pin("E0A2");
Pin* pin3 = new Pin("E0A3");
Pin* pin4 = new Pin("E0A4");
int addr =  GPIOobj.digitalRead(pin0) + GPIOobj.digitalRead(pin1) * 2 + GPIOobj.digitalRead(pin2) * 4 + GPIOobj.digitalRead(pin3) * 8 + GPIOobj.digitalRead(pin4) * 16
Mqtt
Wenn du konkrete Vorstellungen hast, kann ich dich hier gerne bei den ersten Schritten unterstützen. Hier muss eine neue Klasse ähnlich den besthenden cmd<irgendwas> Klassen angelegt werden.
Da ich bislang noch keine Unterstützung für Rückmelder habe, muss hier noch der Controller angepasst werden. Alles aber sehr überschaubarer Aufwand.

Schaltplan
Deinen Schaltplan habe ich ähnlich gesagt nicht verstanden. Darf ich fragen, wo du sie fertigen lässt?
Mit einer Größe von 11,3 cm ist es ja eine "Sondergröße", die deutlich mehr kostet, als wenn die Platine maximal 10 cm groß wäre.

Gruß,
Sven

Lorenzo
Beiträge: 34
Registriert: 20.04.2019, 19:24
Hat sich bedankt: 1 Mal
Danksagung erhalten: 1 Mal

Re: Weichendecoder mit Servo

Beitrag von Lorenzo » 08.06.2019, 09:19

Hallo Sven,

danke für deine Infos und Anmerkungen. Ich werde erst einmal das delay nach deinen Vorgaben umsetzen. Da ich aber in der nächsten Woche unterwegs sein werde, dauert das ein paar Tage. Weiterhin versuche ich mich dann schon mal an den DIP switches und MQTT. Ich versuche, mich da erst einmal etwas hineinzufräsen. Meinen Lösungsansatz stelle ich dann wieder hier zur Diskussion. Falls ich aber vorher noch Verständnisfragen habe, komme ich gern schon wieder vorab auf dich zu.

Zum Board Verständnis hilft vielleicht noch folgendes Bild, in welchem ich zum Test Pappdummys eingebaut habe um zu sehen, ob alles passt:

Gehäuse.png
Gehäuse.png (738.79 KiB) 8402 mal betrachtet
Auf der linken Seite wird das ESP Modul aufgelötet. Es steht dort also senkrecht. Rechts (senkrecht) sind die Anschlüsse. Für Schienenspannung, Weichenherzpolarisierung, Steuereingänge für Weichenaufschneiden sowie einer optionalen alternativen Versorgungsspannung werden dort Lötstifte in die Platine gelötet und durch das Gehäuse geführt. Ich hoffe, das kommt jetzt etwas verständlicher rüber.

Vom Servo wird ein kurzer Edelstahldraht durch das Gehäuse geführt, der dann die Weiche betätigt. Das Gehäuse selbst wird an der Weiche befestigt. Damit ist der Servo dann hoffentlich dauerhaft so gut geschützt, dass die ganze Geschichte freilandtauglich ist.

Die Platinen lasse ich bei allpcb.com fertigen. In dieser Größe kosten 10 Stück 5$ plus Versand. Ich habe dort bereits in der Vergangenheit fertigen lassen und war bisher mit den Ergebnissen zufrieden.

Beste Grüße

Norbert
Beiträge: 300
Registriert: 31.12.2018, 08:07
Hat sich bedankt: 1 Mal
Danksagung erhalten: 71 Mal

Re: Weichendecoder mit Servo

Beitrag von Norbert » 09.06.2019, 15:17

Vielleicht kriegst du da später noch ein Glückwunschkartenmodul für `nen Euro mit in das kleine Gehäuse,
das den typischen Sound des Stellantriebs original wiedergibt.
Nur eine spaßige Idee, aber fetzen würde es.... :lol:
Mich würde final dann auf jeden Fall interessieren, wie es mit der schier unvermeidlichen Zappelei der Servos ausschaut,
also, ob sie zappelfrei arbeiten. Oder sind digitale Servos angedacht?

Für mich ist das Ganze aus vielerlei Gründen zwar nichts,
ich wünsche dir aber auf jeden Fall weiterhin gutes Gelingen bei dem anspruchsvollen Projekt.

VG Norbert

Lorenzo
Beiträge: 34
Registriert: 20.04.2019, 19:24
Hat sich bedankt: 1 Mal
Danksagung erhalten: 1 Mal

Re: Weichendecoder mit Servo

Beitrag von Lorenzo » 16.06.2019, 17:55

Hallo Sven,

nach ein paar Tagen Abwesenheit bin ich jetzt ein Stück weiter gekommen. Senden und Empfange über MQTT funktioniert bereits (auf Basis deines RocnetOverMQTT) :). Auch habe ich zwei Port Expander MCP23017 einbinden können. Im Moment hake ich aber noch an ein paar Kleinigkeiten.
  • Wie kann ich die Daten für IP Adresse, intopic und outtopic aus dem config file über config.cpp meinem neuen CmdReceiverMQTT.cpp bekannt machen, so dass diese Daten dort verwendet werden können
  • Wie kann ich in setServer statt der IP Adresse (192.168.xxx.xxx) einen Namen verwenden, z.B. "rasp-mosquitto"?
  • Wie kann ich die PullUp Widerstände des MCP aktivieren?
Vielleicht kannst du mir da ein bisschen auf die Sprünge helfen ;)

Sobald ich die ersten beiden Punkte gelöst habe, könnte ich den Code für MQTT hier schon mal veröffentlichen.

Beste Grüße
Lorenzo

little.yoda
Site Admin
Beiträge: 882
Registriert: 14.09.2018, 19:05
Hat sich bedankt: 33 Mal
Danksagung erhalten: 143 Mal

Re: Weichendecoder mit Servo

Beitrag von little.yoda » 17.06.2019, 10:13

freut mich ...

zu deinen Fragen:
1.
Schau dir mal den Block unterhalb von "} else if (m.equals("wlan")) {" in config.cpp an.
Teile davon kannst du übernehmen. Du musst dann "nur" den Konstruktur deiner Klasse entsprechend erweitern.

2.
IPAddress ip;
WiFi.hostByName("www.google.com", ip);
Serial.println(ip);

3.
Pull-Ups kannst du über pinMode setzen:
GPIOobj.pinMode(gpio, INPUT_PULLUP, "GPIO");

Melde dich gerne, wenn du noch Fragen hast.

Gruß,
Sven

Lorenzo
Beiträge: 34
Registriert: 20.04.2019, 19:24
Hat sich bedankt: 1 Mal
Danksagung erhalten: 1 Mal

Re: Weichendecoder mit Servo

Beitrag von Lorenzo » 21.06.2019, 11:10

so, es ist mal wieder etwas weiter gegangen. Danke Sven für die Tipps.

Punkt 2. IP Adresse auflösen funktioniert so nicht im eigenen LAN. Ich hatte vorher schon einmal einen Arduino Sketch, in dem es folgendermaßen klappte:

Code: Alles auswählen

client.setServer("rasp-mosquitto", 1883);
client.setCallback(callback);
Damit funktionierte die Namensauflösung in meinem LAN. Warum das im vorliegendem Framework nicht geht, entzieht sich meiner Kenntnis. Da muss ich wohl erstmal mit der IP Adresse leben.

Das MQTT Handling habe ich jetzt in der Datei CmdTransceiverMQTT.cpp untergebracht:

Code: Alles auswählen

/*
 * CmdTransceiverMQTT.cpp
 *
 *
 *  Created on: 17.06.2018
 *      Author: sven
 * Modified on: 12.06.2019
 *
 *
 * set/getTurnout over MQTT
 *
 * MQTT <=> ESP8266
 *
 * Protocoll:
 * Befehl empfangen [setTurnout]
 *		XXStatus		Statusabfrage Weiche XX (XX=00: broadcast)
 *		XXLinks			Weiche XX linker Weg (Rechtsweiche: geradeaus)
 *						im ProgMode: 1 Step nach links
 *		XXRechts		Weiche XX rechter Weg (Rechtsweiche: abzweigen)
 *						im ProgMode: 1 Step nach rechts
 *		XXMitte			Weiche XX in Mittenstellung (für Servojustierung)
 *		XXProgLinksOn	Weiche XX linker Weg Programmiermodus ein
 *		XXProgLinksOff	Weiche XX linker Weg Programmiermodus aus (speichern Servowert links)
 *		XXProgRechtsOn	Weiche XX rechter Weg Programmiermodus ein
 *		XXProgRechtsOff	Weiche XX rechter Weg Programmiermodus aus (speichern Servowert rechts)
 *
 * Status/Zustand senden [getTurnout]
 *		XXLWlinks		Linksweiche XX linker Weg (abzweigen)
 *		XXLWrechts		Linksweiche XX rechter Weg (geradeaus)
 *		XXRWlinks		Rechtsweiche XX linker Weg (geradeaus)
 *		XXRWrechts		Rechtsweiche XX rechter Weg (abzweigen)
 *		XXLWemcyL		Linksweiche XX Aufschneiden links
 *		XXLWemcyR		Linksweiche XX Aufschneiden rechts
 *		XXRWemcyL		Rechtsweiche XX Aufschneiden links
 *		XXRWemcyR		Rechtsweiche XX Aufschneiden rechts
 */

#include "CmdTransceiverMQTT.h"
#include "Utils.h"
#include "Arduino.h"
#include "Controller.h"
#include "Consts.h"
#include "Logger.h"

CmdTransceiverMQTT::CmdTransceiverMQTT(Controller* c, String mqtt_server, String intopic, String outtopic, String mclient, int Addr) : CmdReceiverBase(c) {
	client = new PubSubClient(espClient);
	_instance = this;

	this->server = mqtt_server;
	this->intopic = intopic;
	this->outtopic = outtopic;
	this->turnoutAddr = Addr;
	this->mqttclient = mclient;
}

CmdTransceiverMQTT::~CmdTransceiverMQTT() {
}


CmdTransceiverMQTT *CmdTransceiverMQTT::_instance = NULL;


void CmdTransceiverMQTT::sendStatus(String s) {
	String Addr = (turnoutAddr < 10) ? '0' + String(turnoutAddr) : String(turnoutAddr);
	String payload = Addr + s;
	if (!(client->publish(outtopic.c_str(), payload.c_str()))) {
		Serial.println("publish failed");
	}
}


int CmdTransceiverMQTT::loop() {
	String clientId = mqttclient;
	String a = (turnoutAddr < 10) ? '0'+String(turnoutAddr) : String(turnoutAddr);
	clientId += String(a);
	if (initMQTT == 0) {
		if (WiFi.status() != WL_CONNECTED) {
			return 2000;
		}
		client->setCallback(mqttcallback);
		Serial.println("Callback: mqttcallback");
		client->setServer(server.c_str(), 1883);
		Serial.println("setServer: " + server + ", Port: " + String(1883));
		initMQTT = 1;
	} else if (initMQTT == 1) {
		if  (!client->connected()) {
			// try to connect / reconnect
			if (client->connect(clientId.c_str())) {
				Serial.println(clientId + " is trying to connect to MQTT Server...");
				Serial.println(clientId + " connected");
				client->subscribe(intopic.c_str(), 1);
				Serial.println(clientId + " subscribed to: " + intopic);
			} else {
				client->loop();
			}
		} else {
			client->loop();
		}
	}
	return 500;
}


void mqttcallback(char* topic, byte* payload, unsigned int length) {
//	Serial.print("Message arrived [");
//	Serial.print(topic);
//	Serial.print("] ");
	payload[length] = 0;
	String payloads = String((char*)payload);
//	Serial.println(payloads);
	CmdTransceiverMQTT::_instance->parse(payloads);
}

void CmdTransceiverMQTT::parse(String s) {
	int dir = 0;
	int Addr = s.toInt();	// string starts with turnoutAddr
	if (Addr == 0) {
		Serial.print("broadcast ");
		Addr = turnoutAddr;	// convert broadcast to own addr
	}
//	String a = (Addr < 10) ? '0'+String(Addr) : String(Addr);

	if (Addr == turnoutAddr) {
	String status;
		if (s.substring(2) == "Links") {
			dir = 1;
			controller->notifyTurnout(Addr, dir, 0);
			status = "Links";
		} else if (s.substring(2) == "Rechts") {
			dir = 0;
			controller->notifyTurnout(Addr, dir, 0);
			status = "Rechts";
		} else if (s.substring(2) == "Mitte") {
			Serial.println("cmd 'Mitte' coming soon");
			status = ": n/a Mitte";
		} else if (s.substring(2) == "ProgLinksOn") {
			Serial.println("cmd 'ProgLinksOn' coming soon");
			status = ": n/a Prog";
		} else if (s.substring(2) == "ProgLinksOff") {
			Serial.println("cmd 'ProgLinksOff' coming soon");
			status = ": n/a Prog";
		} else if (s.substring(2) == "ProgRechtsOn") {
			Serial.println("cmd 'ProgRechtsOn' coming soon");
			status = ": n/a Prog";
		} else if (s.substring(2) == "ProgRechtsOff") {
			Serial.println("cmd 'ProgRechtsOff' coming soon");
			status = ": n/a Prog";
		} else if (s.substring(2) == "Status") {
			Serial.println("cmd 'Status' coming soon");
			status = ": n/a Prog";
		} else {
			Serial.println("unknown cmd '" + s.substring(2) + "'");
			status = ": n/a cmd: '" + s.substring(2) + "'";
		}
		CmdTransceiverMQTT::_instance->sendStatus(status);
	}
}
dazu die Datei CmdTransceiverMQTT.h:

Code: Alles auswählen

/*
 * CmdTransceiverMQTT.h
 *
 *  Created on: 17.06.2018
 *      Author: sven
 * Modified on: 12.06.2019
 */


#ifdef ESP8266
	#include <ESP8266WiFi.h>
#elif ESP32
	#include <WiFi.h>
#else
	#error "This Arch is not supported"
#endif

#include <WiFiUdp.h>
#include "PubSubClient.h"
#include "CmdReceiverBase.h"

#ifndef CMDTRANSCEIVERMQTT_H_
#define CMDTRANSCEIVERMQTT_H_

class CmdTransceiverMQTT: public CmdReceiverBase  {
public:
	static CmdTransceiverMQTT* _instance; // Hack for access from PubSubClient
	CmdTransceiverMQTT(Controller* c, String mqtt_server, String intopic, String outtopic, String mclient, int Addr);
	virtual ~CmdTransceiverMQTT();
	virtual int loop();
	void parse(String s);
	void sendStatus(String s);

private:
	WiFiClient espClient;
	PubSubClient* client;
	String extractString(String payloads, String begin, String end);
	String server;
	String intopic;
	String outtopic;
	int initMQTT = 0;
	int turnoutAddr = 0;
	String mqttclient;
//	bool isRighthandTurnout;
};

void mqttcallback(char* topic, byte* payload, unsigned int length);

#endif /* CMDTRANSCEIVERMQTT_H_ */
Die Daten im config.json dazu sind wie folgt:

Code: Alles auswählen

		{
			"m": "mqtt",
			"server": "192.168.1.19",
			"intopic": "setTurnout",
			"outtopic": "getTurnout",
			"client": "ESPTurnoutClient-"
		}
Hier ist auch zusätzlich der Basisname des MQTT client angegeben. Für die Eindeutigkeit wird daran noch in CmdTransceiver.cpp die turnout Adresse angehängt. Im config.cpp werden die Parameter so übergeben:

Code: Alles auswählen

		} else if (m.equals("mqtt")) {
			String server = parser->getValueByKey(idx, "server");
			String intopic = parser->getValueByKey(idx, "intopic");
			String outtopic = parser->getValueByKey(idx, "outtopic");
			String mqttclient = parser->getValueByKey(idx, "client");
			controller->registerCmdReceiver(new CmdTransceiverMQTT(controller, server, intopic, outtopic, mqttclient, turnoutAddr));

		}
Innerhalb der MQTT Routinen habe ich auch mein eigenes Protokoll zum Ansprechen der Weichen untergebracht. Das macht das Ganze jetzt etwas weniger generisch. Vielleicht gibt es ja noch eine Anregung, wie man das entkoppeln könnte. Funktionieren tut Senden und Empfangen über MQTT auf jeden Fall.

Etwas unglücklich bin ich noch mit der Behandlung der Porterweiterung über MCP23017. Im Moment muss ich noch überall, wo ich den Port einlesen möchte, oder etwas ausgeben möchte, den Pin deklarieren und über GPIOobj darauf zugreifen. Keine Ahnung, ob das auch besser/einfacher geht. Auf jeden Fall funktioniert es erst einmal wie gewünscht.


Beste Grüße
Lorenzo

little.yoda
Site Admin
Beiträge: 882
Registriert: 14.09.2018, 19:05
Hat sich bedankt: 33 Mal
Danksagung erhalten: 143 Mal

Re: Weichendecoder mit Servo

Beitrag von little.yoda » 21.06.2019, 18:42

Lorenzo hat geschrieben:
21.06.2019, 11:10
so, es ist mal wieder etwas weiter gegangen. Danke Sven für die Tipps.
:D

Lorenzo hat geschrieben:
21.06.2019, 11:10
Punkt 2. IP Adresse auflösen funktioniert so nicht im eigenen LAN. Ich hatte vorher schon einmal einen Arduino Sketch, in dem es folgendermaßen klappte:

Code: Alles auswählen

client.setServer("rasp-mosquitto", 1883);
client.setCallback(callback);
Ich habe gerade etwas gegoogelt:
Anscheinend brauchst du eine weitere Lib, um mdns Auflösung betreiben zu können
Ich schaue bei Gelegenheit mal, ob ich eine generische Funktion einbauen kann, die auch mdns unterstützt.


Lorenzo hat geschrieben:
21.06.2019, 11:10
Etwas unglücklich bin ich noch mit der Behandlung der Porterweiterung über MCP23017. Im Moment muss ich noch überall, wo ich den Port einlesen möchte, oder etwas ausgeben möchte, den Pin deklarieren und über GPIOobj darauf zugreifen. Keine Ahnung, ob das auch besser/einfacher geht. Auf jeden Fall funktioniert es erst einmal wie gewünscht.
Kann ich verstehen. Ich habe ein paar Ideen, aber noch nichts implementiert.
Im Prinzip schwebt mir vor, dass man Variablen im Config-File definieren kann, die auf GPIO zurückgreifen.
Aber diesen Ansatz habe ich noch nicht zu ende durchdacht.

Gruß,
Sven

Lorenzo
Beiträge: 34
Registriert: 20.04.2019, 19:24
Hat sich bedankt: 1 Mal
Danksagung erhalten: 1 Mal

Re: Weichendecoder mit Servo

Beitrag von Lorenzo » 22.06.2019, 09:51

little.yoda hat geschrieben:
21.06.2019, 18:42
Ich habe gerade etwas gegoogelt:
Anscheinend brauchst du eine weitere Lib, um mdns Auflösung betreiben zu können
Ich schaue bei Gelegenheit mal, ob ich eine generische Funktion einbauen kann, die auch mdns unterstützt.
Mir war nicht bewusst, dass der Arduino Sketch, in dem die Namensauflösung bei mir funktioniert, eine mdns Auflösung explizit eingebunden hat. Muss er ja aber irgendwie. Aber so tief stecke ich in der Materie auch noch nicht drin. Im Moment kann ich mit IP Adresse aber noch gut leben. Namensauflösung wäre halt schon schön...
little.yoda hat geschrieben:
21.06.2019, 18:42
Im Prinzip schwebt mir vor, dass man Variablen im Config-File definieren kann, die auf GPIO zurückgreifen.
Aber diesen Ansatz habe ich noch nicht zu ende durchdacht.
Kann man dann auf diese Variablen auch von allen Programmteilen aus zugreifen? Diese ganze Trennung mit Klassen hat in Bezug auf Übersichtlichkeit ja was für sich, stellt mich aber immer noch vor einige Herausforderungen. Da komme ich erst ganz langsam dahinter, wie das geht. Dank deiner geduldigen Unterstützung :D

Dazu dann gleich noch eine Frage: wie stelle ich das an, aus ConnectorTurnout2Value heraus einen Status-String an CmdTransceiverMQTT zu schicken, so dass dieser dann die dortige publish Funktion nutzt um den Status über MQTT zu senden?

Beste Grüße
Lorenzo

Antworten