INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
String als Funktion einsetzen
25.02.2014, 19:36
Beitrag #25
RE: String als Funktion einsetzen
Super dass du es geschafft hast. Das zeigt dass du dich "festbeissen" kannst.
Ist eine Eigenschaft die Schreiber von Programmen unbedingt haben sollten Smile

Grüße RK

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
25.02.2014, 20:24 (Dieser Beitrag wurde zuletzt bearbeitet: 25.02.2014 20:37 von Kikdiweg.)
Beitrag #26
RE: String als Funktion einsetzen
Zitat:Aus den vielen Posts kann ich jetzt nicht mehr wiirklich ersehen, was beim Senden über netcat auf dem Arduino ankommen soll. Schreibe mal bitte ein "Ablaufbeispiel" auf.
Nach dem Motto:
netcat sendet "abcde"
beim Arduino kommt "xyz" an
dieser Inhalt soll im Arduino folgendes machen:...

Ideal wär eben folgendes:

netcat sendet: ?vx#

Arduino liest: ? = Zeichenkette Anfang
v = Caseselector (v=Variable auslesen; a wäre Analogpin direkt lesen)
x=Name der Variable die ich auslesen möchte
(Den gelesenen Buchstaben x speichere ich in der variable varIn)

#=Zeichenkette Ende

Bis dahin funktioniert alles, nur siehts dann wenn er mit
client.println(varIn) antworten soll so aus


varIn -------------> x -------/////------->> 0178

Er löst varIn zu x auf aber x dann nicht mehr zu dem Wert (0178).

Ich weiss zwar dank Thorsten nun warum, aber ist meiner Meinung nach total sinnfrei.

Was spricht dagegen Variablen(zumindest einstellige) so zu hinterlegen dass sie abrufbar sind. Ich mein er kann ja auch Zeichenketten die er über Seriell oder Ethernet bekommt lesen und Zahlen auch in den Code einsetzen.
Warum gibt es keine Art Register für Variablen?

Mir will einfach nicht in den Kopf wo genau zwischen "unveränderbarer auf dem Arduino gespeicherter Code" und "Von aussen veränderbar" die Grenze verläuft.

Code:
client.println(analogRead(varIn)
und
Code:
client.println(x[varIn])
funktionieren doch auch

Code:
client.println(variableRead(varIn)
wäre die Lösung, falls es denn irgendwas dergleichen gäbe

Kennt ihr das Gefühl wenn ihr beim Versuch etwas zu verstehen immer wieder ins leere greift?

Ich poste auch nochmal meinen kompletten Code damit ihr seht warum ich sowas gern hätte.

Falls ich irgendwem mit meinem ewigen Nachbohren auf den Geist gehe soll tuts mir leid, aber ich bin so Tongue
Code:
#include <SPI.h>
#include <Ethernet.h>
#include <DallasTemperature.h>
#include <OneWire.h>
#include "LiquidCrystal.h"
#include <Wire.h>
#include <elapsedMillis.h>
#include <SD.h>


boolean heaterOn = false;
boolean Pstat;
char thisChar;
const int Brenner = 35;
const int Mischer_AUF = 31;
const int Mischer_ZU = 32;
const int Pumpe = 33;
elapsedMillis logIntervall;
elapsedMillis Mpause;
File myFile;
float Aist;
float Bist;
float Kist;
float R1;
float R2;
float V1;
float V2;
int diftime;
int hyst = 2;
int Ksoll = 60;
int mstat;
int Spanne = 10;
int tempist;
int tempsoll = 24;
int tempstor = 0;
LiquidCrystal lcd( 22, 23, 24, 25, 26, 27);
String chars;
String readString;
unsigned long coldtime = 0;
unsigned long interval = 80000;
unsigned long warmtime = 0 ;

////////////////////////////////ETHERNET////////////////////////////////////
byte mac[] =
{
    0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
};
IPAddress ip(192, 168, 1, 177);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 1, 0);
EthernetClient client = 0;
EthernetServer server(23);
unsigned long timeOfLastActivity; //time in milliseconds of last activity
unsigned long allowedConnectTime = 20000; //five minutes
int alreadyConnected = 0;
/////////////////////////////////////ONEWIRE////////////////////////////////////////
OneWire oneWire(8);
float wire[3];
DallasTemperature sensors(&oneWire);
DeviceAddress Kessel =
{0x10, 0xE8, 0x4A, 0x29, 0x02, 0x08, 0x00, 0xFD};
DeviceAddress Aussen =
{0x10, 0x3C, 0x08, 0x29, 0x02, 0x08, 0x00, 0x8F};
DeviceAddress Brauch =
{0x10, 0x57, 0x0B, 0x29, 0x02, 0x08, 0x00, 0xFA};
//////////////////////////////////////MISCHER////////////////////////////////////////////
String conv;
String val;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup()
{
    lcd.begin(16, 2);
    Ethernet.begin(mac, ip, gateway, gateway, subnet);
    server.begin();
    sensors.begin();
    sensors.setResolution(Kessel, 10);
    sensors.setResolution(Aussen, 10);
    sensors.setResolution(Brauch, 10);
    Serial.begin(9600);

    while (!Serial)
        {
            ;
        }

    pinMode(4, OUTPUT);
    pinMode(53, OUTPUT);
    pinMode(33, OUTPUT);
    pinMode(Brenner , OUTPUT);
    pinMode(Mischer_AUF, OUTPUT);
    pinMode(Mischer_ZU, OUTPUT);
    Pstat = false;

    if (!SD.begin(4))
        {
            Serial.println("initialization failed!");
            return;
        }

    Serial.println("initialization done.");
    Serial.print("Server address:");
    Serial.println(Ethernet.localIP());
    Serial.println("HV;HR;BV;BR;Kessel;Aussen;Brauch;HV SOLL;Pumpe;Mstat;MProzent");
    digitalWrite(33, LOW);
    digitalWrite(4, HIGH);
    digitalWrite(Brenner, LOW);
    digitalWrite(Mischer_AUF, LOW);
    digitalWrite(Mischer_ZU, LOW);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////7
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

float readtemp(int pin)
{
    float temp;
    int i;
    int res[20];
    int sum = 0;
    int x;

    for (int x = 1; x <= 20; x++)
        {
            int t = analogRead(pin);
            res[x] = t;
            sum = sum + res[x];
            temp = (sum / 20) * 4.8 / 1024;
            temp = temp - 0.5;
            temp = temp / 0.01;
        }

    return temp;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

void BrennSteu()
{
    if (sensors.getTempC(Kessel) < (Ksoll - Spanne) && !heaterOn)
        {
            digitalWrite(Brenner, HIGH);
            heaterOn = true;
        }

    if (sensors.getTempC(Kessel) >= Ksoll)
        {
            digitalWrite(Brenner, LOW);
            heaterOn = false;
        }
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mischen()
{
    if (millis() > 120000)
        {
            digitalWrite(Mischer_ZU, LOW);
            digitalWrite(Mischer_AUF, LOW);

            //WartenA = millis();    //alles 10 Sekunden die Temperaturen vergleichen
            if (Mpause > 80000)
                {
                    if (tempist > (tempsoll + hyst))    // Mischer zu - Temperatur runter
                        {
                            //MischenA = millis();
                            elapsedMillis Mtime = 0;
                            coldtime = coldtime + ((tempist - tempsoll) * 400);

                            while (Mtime < ((tempist - tempsoll) * 400))
                                {
                                    //z.B.tempist=27(Grad) und tempsoll= 22(Grad) dann geht der Mischer 5*400ms also 2,5sec lang zu
                                    digitalWrite(Mischer_ZU, HIGH);
                                    Serial.print("Mischzeit ist ");
                                    Serial.println(((tempist - tempsoll) * 400));
                                    Serial.println("Mischer faehrt ZU");
                                    mstat = 32;
                                }

                            digitalWrite(Mischer_ZU, LOW);
                        }

                    if (tempist < (tempsoll - hyst))      // Mischer auf - Temperatur erhoehen
                        {
                            //MischenA = millis();
                            elapsedMillis Mtime = 0;
                            warmtime = warmtime + ((tempsoll - tempist) * 400);

                            while (Mtime < ((tempsoll - tempist) * 400))
                                {
                                    digitalWrite(Mischer_AUF, HIGH);
                                    Serial.print("Mischzeit ist ");
                                    Serial.println(((tempsoll - tempist) * 400));
                                    Serial.println("Mischer faehrt AUF");
                                    mstat = 31;
                                }

                            digitalWrite(Mischer_AUF, LOW);
                        }

                    Mpause = 0  ;
                }

            if (coldtime > warmtime)
                {
                    coldtime = 0;
                    warmtime = 0;
                }

            if (warmtime - coldtime > 100000)
                {
                    warmtime = 100000;
                    coldtime = 0;
                }

            diftime = (warmtime - coldtime) / 1000;
        }
    else
        {
            digitalWrite(Mischer_ZU, HIGH);
        }
} //--------MISCHEN Ende-----------------

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop()

{
    // wait for a new client:
    // Place your custom loop code here (this may slow down communication with LabVIEW)
    sensors.requestTemperatures();
    delay(500);
    tempist = (readtemp(0));
    V1 = tempist;
    R1 = readtemp(1);
    V2 = readtemp(2);
    R2 = readtemp(3);
    Kist = sensors.getTempC(Kessel);
    Aist = sensors.getTempC(Aussen);
    Bist = sensors.getTempC(Brauch);
    //analogPin1 = analogRead(1);
    //Pstat = digitalRead(33);
    //Brstat = digitalRead(Brenner);
    EthernetClient client = server.available();

    if (client.connected() > 0)
        {
            if (client)
                {
                    thisChar = client.read();
                    chars = chars + thisChar;

                    //////////////////////////////////////////////////////////////////////////////////////////
                    if (thisChar == '\n');

                    {
                        Serial.println(thisChar);
                        Serial.println(chars);

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("hv") > -1)
                            {
                                client.println(readtemp(0));
                                delay(500);
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("hr") > -1)
                            {
                                client.println(readtemp(1));
                                delay(500);
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("bv") > -1)
                            {
                                client.println(readtemp(2));
                                delay(500);
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("br") > -1)
                            {
                                client.println(readtemp(3));
                                delay(500);
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("aussen") > -1)
                            {
                                sensors.requestTemperatures();
                                delay (750);
                                float tempC = sensors.getTempC(Aussen);
                                client.println(tempC);
                                delay(500);
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("kessel") > -1)
                            {
                                sensors.requestTemperatures();
                                delay (750);
                                float tempC = sensors.getTempC(Kessel);
                                client.println(tempC);
                                delay(500);
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("brauch") > -1)
                            {
                                sensors.requestTemperatures();
                                delay (750);
                                float tempC = sensors.getTempC(Brauch);
                                client.println(tempC);
                                delay(500);
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("pan") > -1)
                            {
                                digitalWrite(33, HIGH);
                                Pstat = true;
                                delay(500);
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("paus") > -1)
                            {
                                digitalWrite(33, LOW);
                                Pstat = false;
                                delay(500);
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("pstat") > -1)
                            {
                                client.println(Pstat);
                                delay(500);
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("hwarm") > -1)
                            {
                                tempsoll = tempsoll + 1;
                                client.println(tempsoll);
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("hkalt") > -1)
                            {
                                tempsoll = tempsoll - 1;
                                client.println(tempsoll);
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("calibrate") > -1)
                            {
                                tempsoll = 1;
                                warmtime = 100000;
                                coldtime = 0;
                                client.println(tempsoll);
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("hsoll") > -1)
                            {
                                Serial.println(chars.indexOf("t"));
                                String conv  = chars.substring(chars.indexOf("t") + 1, chars.indexOf("t") + 3) ;
                                int numb = conv.toInt();
                                Serial.println(numb);
                                tempsoll = numb;
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("ksoll") > -1)
                            {
                                Serial.println(chars.indexOf("t"));
                                String conv  = chars.substring(chars.indexOf("t") + 1, chars.indexOf("t") + 3) ;
                                int numb = conv.toInt();
                                Serial.println(numb);
                                Ksoll = numb;
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("data") > -1)
                            {
                                client.print(V1);
                                client.print(F(";"));
                                client.print(R1);
                                client.print(F(";"));
                                client.print(V2);
                                client.print(F(";"));
                                client.print(R2);
                                client.print(F(";"));
                                client.print(Kist);
                                client.print(F(";"));
                                client.print(Aist);
                                //   delay(500);
                                client.print(F(";"));
                                client.print(Bist);
                                client.print(F(";"));
                                client.print(tempsoll);
                                client.print(F(";"));
                                client.print(Pstat);
                                client.print(F(";"));
                                client.print(mstat);
                                client.print(F(";"));
                                client.print(diftime);
                                client.print(F(";"));
                                client.print(warmtime - coldtime);
                                client.print(F(";"));
                                client.print(heaterOn);
                                client.print(F(";"));
                                client.print(Ksoll);
                                client.println("#");
                                chars = "";
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                        /////////////////////////////////////////////////////////////////////////////////////////////
                        if (chars.indexOf("#") > -1)
                            {
                                // client.println(chars);
                                // client.println(chars.indexOf("?"));
                                // client.println(chars.indexOf("("));
                                conv  = chars.substring(chars.indexOf("?") + 1) ;
                                val  = chars.substring(chars.indexOf("?") + 2, chars.indexOf("#")) ;
                                int numb = val.toInt();
                                //client.println(conv);
                                client.println(numb);
                                //client.println(conv + (numb));
                                chars = "";

                                switch (conv[0])
                                    {
                                        case 'w':
                                            break;

                                        case 'a':
                                            client.println(analogRead(numb));
                                            break;

                                        case 'v':
                                            client.println(val);
                                            // client.println(analogPin1);
                                            break;

                                        default:
                                            break;
                                    }
                            }

                        if (chars.indexOf("log") > -1)
                            {
                                myFile = SD.open("log.txt", FILE_READ);

                                while (myFile.available())
                                    {
                                        client.print(myFile.read());
                                    }

                                myFile.close();
                            }

                        /////////////////////////////////////////////////////////////////////////////////////////////
                    }//if(thisChar == '\n') ENDE
                }//if CLIENT Ende
        }//IF CLIENT CONNECTED ENDE

    if (Kist < 45)
        {
            digitalWrite(33, LOW);
            Pstat = false;
        }

    mischen();
    BrennSteu();
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(V1, 1);
    lcd.setCursor(5, 0);
    lcd.print(R1, 1);
    lcd.setCursor(10, 0);
    lcd.print(Kist, 1);
    lcd.setCursor(0, 1);
    lcd.print(V2, 1);
    lcd.setCursor(5, 1);
    lcd.print(R2, 1);
    lcd.setCursor(10, 1);
    lcd.print(Bist, 1);

    if (logIntervall > 20000)
        {
            myFile = SD.open("log.txt", FILE_WRITE);

            if (myFile)
                {
                    myFile.print(V1);
                    myFile.print(";");
                    myFile.print(R1);
                    myFile.print(";");
                    myFile.print(V2);
                    myFile.print(";");
                    myFile.print(R2);
                    myFile.print(";");
                    myFile.print(Kist);
                    myFile.print(";");
                    myFile.print(Aist);
                    myFile.print(";");
                    myFile.print(Bist);
                    myFile.print(";");
                    myFile.print(Pstat);
                    myFile.print(";");
                    myFile.print(mstat);
                    myFile.print(";");
                    myFile.print(tempsoll);
                    myFile.print(";");
                    myFile.print(diftime);
                    myFile.print(";");
                    myFile.print(warmtime - coldtime);
                    myFile.print(";");
                    myFile.print(heaterOn);
                    myFile.println("#");
                    myFile.close();
                }//myFile END

            logIntervall = 0;
        }//logintervall END
}//lOOP eNDE
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
25.02.2014, 20:32
Beitrag #27
RE: String als Funktion einsetzen
(25.02.2014 20:24)Kikdiweg schrieb:  Falls ich irgendwem mit meinem ewigen Nachbohren auf den Geist gehe soll tuts mir leid, aber ich bin so Tongue

Nö - Du hast doch versucht es zu verstehen - und auch mitgearbeitet und weitergedacht - falsch denken oder, was meine Spezialïtät ist: "zu kompliziert", tun wir alle irgendwann.

Und glaub mir irgendwer - steht genau vor dem Problem - und liest den Thread und denkt Huh Dodgy Exclamation

Die Leutz hier beissen meistens auch nicht und auch Brückenpfeiler fliegen nur selten...
also keine Bange, darfst Dich an die nächste Aufgabe wagen - und WEITERBOHREN...

nicht das es hier langweilig wird.
Greetz
Sloompie

ach ja Bohrmaschine kann ich Dir leihweise zur Verfügung stellen Smile

Dimidium facti, qui coepit, habet: SAPERE AUDE, incipe!©Horaz

Vor allem sapere aude! oder wie Immanuel Kant sagt:
"Habe Mut, dich deines eigenen Verstandes zu bedienen!"

Es tut auch nicht weh! Daher: incipe! oder Tu es! wie Yoda sagen würde.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
25.02.2014, 20:35
Beitrag #28
RE: String als Funktion einsetzen
Hi,

ich hab' das nur mal schnell überflogen, aber ist das eine komplette Brennersteuerung? Kennst Du Dich damit aus? Ich frage, weil ich gerade in einem ähnlichen Projekt stecke.

Von wegen Variablen: Natürlich könnte ein System das theoretisch ablegen. Es gibt auch Programmiersprachen, bei denen geht sowas (ABAP zum Beispiel). Allerdings wird das wahrscheinlich für den kleinen Arduino etwas zu viel und meistens braucht man's auch nicht. Bei einer "übersetzten" Programmiersprache würde einfach niemand erwarten, dass das System Speicher verbraucht, um sich die Variablenreferenzen zu merken.

Gruß,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
25.02.2014, 20:54 (Dieser Beitrag wurde zuletzt bearbeitet: 25.02.2014 21:05 von Kikdiweg.)
Beitrag #29
RE: String als Funktion einsetzen
Ist eine Brennersteuerung ja.
Allerdings ohne Heizkurve. Steuern tu ich das ganze mit nem Androidhandy, dafür brauch ich eben, damit ich nicht jedesmal viel am Code oder aufm Handy verändern muss sobald ich was verändere, eine Art "universelle Schnittstelle".
Ist auch noch eine ziemliche Baustelle das ganze. Funktioniert zwar bis auf das auslesen des Logfiles alles, wuerde es aber noch nicht ohne doppelten Boden laufen lassen. Der Code ist auch noch recht wirr und bestimmt liegen ein paar Variablenleichen rum.


Auskennen? Kommt drauf an.
Eigentlich schon, bin allerdings kein Heizungsbauer. Das ist allerdings schon meine zweite Steuerung die ich mache.
Die erste hab vor 2 Jahren ich mit einer SPS von microsps.com gemacht. Die lief bisher auch anstandslos.
Ich wollte aber unbedingt ordentliche Netzwerkfähigkeit, und deshalb ein neuer Anlauf mit dem Arduino.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
25.02.2014, 21:06
Beitrag #30
RE: String als Funktion einsetzen
Hi,
cool. Ich wollte bei mir nicht gleich die komplette Steuerung ersetzen, da ich etwas Bedenken habe von wegen Sicherheit. Mir ist noch nicht ganz klar, wie ich z.B. den STB bzw. STW einbinde. Außerdem weiß ich nicht, was "Sicherheitskreis 1" und "Sicherheitskreis 2" mit dem Brenner macht.
Jetzt baue ich mir etwas, das (unter Anderem) der eigentlichen Regelung eine bestimmte Außentemperatur vorgaukelt (Digitalpotis statt der Temperaturfühler). Darüber kann ich dann die Vorlauftemperatur regeln ohne in den ganzen Sicherheitskritischen Kram einzugreifen.
Die Vorlauftemperatur will ich dann über die Ventilstellungsgrade der Heizungsventile regeln. D.h. je mehr Heizbedarf meine Ventile anzeigen, desto wärmer wird der Vorlauf.
Gruß,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
25.02.2014, 21:20
Beitrag #31
RE: String als Funktion einsetzen
Was hast du denn momentan fuer eine Regelung, dass du bei der den Vorlauf nicht justieren kannst. Ist eine Ölheizung oder?
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
25.02.2014, 21:23
Beitrag #32
RE: String als Funktion einsetzen
Ja, Ölheizung Giersch Multijet mit einer Giematic-Regelung. (Auch als Theta bekannt.)
Ich kann da schon was regeln, aber eben nicht von außen, sondern nur direkt am Kessel.

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  String / HTTP Request Marc2014 2 76 08.12.2016 09:05
Letzter Beitrag: amithlon
  String zusammensetzen Mathias 13 557 01.09.2016 21:15
Letzter Beitrag: Mathias
  String-Array füllen? torsten_156 9 452 08.07.2016 20:07
Letzter Beitrag: amithlon
  String in EEPROM Speichern BennIY 2 418 27.06.2016 10:23
Letzter Beitrag: BennIY
  Funktion mit Parameterübergabe - u8g torsten_156 8 404 22.06.2016 18:53
Letzter Beitrag: Pit
  String - Buchstabenposition auswerten scritch 5 667 01.04.2016 16:25
Letzter Beitrag: rkuehle
  Funktion in Loop einmalig ausführen Haustechno 4 647 09.03.2016 22:43
Letzter Beitrag: Haustechno
  String nach UTF16 konvertieren (UTF-16) ThoEngel 0 303 20.02.2016 19:22
Letzter Beitrag: ThoEngel
  HC-05 Modul auf Funktion prüfen. arduinofan 2 366 03.02.2016 19:18
Letzter Beitrag: arduinofan
  Eine Funktion vorher definieren ? arduinofan 23 2.031 30.12.2015 08:42
Letzter Beitrag: amithlon

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste