Show Posts
Pages: [1] 2 3 ... 164
1  International / Deutsch / Re: Arduino Nano v3 (sainsmart) stürzt ab ohne Serial Monitor on: Today at 02:27:20 pm
Kann man nicht ausschließen, aber wie kann ein aktiver Serial Monitor dazu führen, dass es keinen Absturz gibt?

Vielleicht unterschiedliches Störverhalten verschiedener Komponenten der Schaltung in Bezug auf die "Elektromagnetische Verträglichkeit" in Verbindung mit nicht ausreichender Fehlerbehandlung in der Software?
2  International / Deutsch / Re: Arduino Nano v3 (sainsmart) stürzt ab ohne Serial Monitor on: Today at 12:54:54 pm
Womit könnte das zusammenhängen?

Mit Programmierfehlern im verwendeten Sketch.

Das war ja einfach.  smiley-lol
3  International / Deutsch / Re: Daten über Lichtimpulse an Arduino senden on: Today at 11:14:35 am
Wenn
Code:
Serial.begin(10);
erlaubt ist, und auch funktioniert wäre das großartig. Dann hätte ich wirklich eine sehr einfache Lösung. Muss ich mir anschauen.

Erlaubt ja, verbietet Dir niemand.
Funktioniert, nein.

Unter ca. 250 Baud kannst Du auf einem 16 MHz AVR Controller nicht verwenden, weil sonst ein größerer Baudratenteiler eingestellt werden müßte als er in das zuständige Baudratenregister hineinpasst.

Mit einem "Serial.begin(10);" wirst Du also keine serielle Verbindung mit 10 Baud aufbauen können.

Du kannst Dir aber mal "SoftwareSerial" ansehen, da diese Library nicht die Hardware-Baudratenregister verwendet, könnte es dort anders sein und ggf. beim selben Controller-Takt niedrigere Baudraten unterstützt werden. Ich habe mir den Code diesbezüglich nicht angesehen, aber möglich wäre es (ggf. nach Modifikation der Library?).
4  International / Deutsch / Re: @jurs: Multitimer 2.0 on: Today at 10:23:29 am
Hi Du, habe ein bisschen rumgespielt und lasse Deinen Multitimer jetzt linear hoch- und runterzählen unter Einhaltung oberer und unterer Grenzen. Mit nur 5 Variablen geht dann schon sowas:

Danke fürs Zeigen, was Du mit Hilfe des "Multitimer" Democodes gebastelt hast!

Ist ja auch mal ganz interessant zu sehen, für was jemand so ein Codestückchen dann tatsächlich verwendet.
5  International / Deutsch / Re: Serial Daten von SD zum PC Uebertragen und in Datei speichern on: Today at 07:41:27 am
  wuerde das mit GtkTerm gehen

Mal kurz nachgeschaut bei den Features unter https://fedorahosted.org/gtkterm/ und sehe da:
Possible to send a file (only RAW data, no protocol)

Das bedeutet: GtkTerm kann beherrscht KEINE gesicherte Dateiübertragung mit irgendeinem Datei-Übertragungsprotokoll.

Mit GtkTerm kannst Du allenfalls folgendes machen:

1. In Deinem GtkTerm öffnest Du eine "Logdatei" (Funktion "Logging to File" oder ähnlich) und gibst den Log-Dateinamen an.

2. Du gibst im GtkTerm einen Befehl an den Arduino ein, um die Datei zu erhalten, z.B.
Code:
GET filename.txt

3. Auf Deinem Arduino läuft ein Sketch, der solche Befehle auswertet und daraufhin über die serielle Schnittstelle die Datei "filename.txt" sendet, ein Byte nach dem anderen

4. Wenn keine Bytes mehr vom Arduino kommen, beendest Du das Logging in Datei

Zum Empfang weiterer Dateien den Vorgang wiederholen.

Falls bei der Übertragung durch Störimpulse Fehler auftreten, ist die auf diese Art empfangene Datei dann nicht identisch mit der gesendeten Datei, Übertragungsfehler werden nicht erkannt.

Wenn es komfortabler werden soll, muss das Terminalprogramm als Feature "Dateiübertragung mit Protokoll" anbieten, und zwar mit mindestens einem der Protokolle:
- XMODEM
- YMODEM
- ZMODEM

Und zugleich muss das Protokoll XMODEM, YMODEM oder ZMODEM im Arduino implementiert werden.

ZMODEM kommt Deinem Wunsch nach Automatisierung des Dateiempfangs wahrscheinlich am nächsten, denn es gibt Terminalprogramme, die ein "Auto ZMODEM" Feature unterstützen, so dass Downloads per ZMODEM ohne weitere Benutzereingriffe möglich sind.

XMODEM wäre aber am einfachsten zu implementieren und benötigt auch am wenigstens RAM-Speicher, da dabei die gesendeten Datenblöcke immer nur 128 Bytes groß sind. Allerdings überträgt das XMODEM-Protokoll noch nicht einmal den Namen einer Datei, sondern nur dessen Inhalt.

Oder Du denkst Dir ein eigenes Übertragungsprotokoll aus statt eines der üblichen Standardprotokolle zu verwenden. Allerdings mußt Du dann auch die PC-seitige Empfangssoftware selbst programmieren und kannst dafür kein Standard-Terminalprogramm verwenden

6  International / Deutsch / Re: String (objekt) vs. char array on: April 22, 2014, 12:36:46 pm
Der Code funktioniert, nur kommt es mir zu aufwendig vor. Evtl. gibt es eine elegantere lösung ?  

Code:
void Parse_int(char* request, char* searchstr, int &value)
{
  char* str=strstr(request,searchstr);
  if (str==NULL) value=-1; // Fehlerwert
  else value=atoi(str+strlen(searchstr));
}

void setup() {
  Serial.begin(9600);
  int monat,tag;
  char request[]="GET /page4.htm?Tag=22&monat=4 HTTP/1.1";
  Parse_int(request, "monat=", monat);
  Serial.print("Monat: ");Serial.println(monat);
  Parse_int(request, "Tag=", tag);
  Serial.print("Tag: ");Serial.println(tag);
}

void loop() {}
7  International / Deutsch / Re: Jahreszahlformat - RTC Winterzeit-Sommerzeit on: April 20, 2014, 05:13:50 am
ich bin gerade dabei die Sache mit der RTC anzupassen und nutze dafür den Code von jurs.
Danke erstmal dafür. 1A.

Du nutzt offenbar einen modifizierten Code von jurs.
Mein Code war leicht wiederverwertbar, weil er die zur Berechnung notwendigen Parameter beim Funktionsaufruf übergeben bekommen hat. Außerdem hat mein Code die Zeitzone berücksichtigt, so daß man sowohl eine UTC-Zeit (timezone=0) eine "Winterzeit"  (timezone=1) oder eine Sommerzeit (timezone=2) übergeben konnte und man hat das richtige Ergebnis erhalten. Das ist nach Wegrationalisierung der timezone irgendwie nicht mehr der Fall.

Dein Code nutzt nun globale Variablen zur Berechnung innerhalb der Funktion.
Kann man machen, aber dann muss man immer aufpassen, womit man rechnet.

Übergibt man der Funktion die Jahreszahl 4stellig, ist alles i.O.
Übergibt man der Funktion die Jahreszahl 2stellig, funktioniert sie nicht mehr.
Warum?

So auf den ersten Blick sage ich mal: Die Funktionen liefern dieselben Ergebnisse, wenn sie mit denselben Werten rechnen. Allerdings rechnet die eine Funktion mit einer globalen Variablen "year" und die andere mit einer globalen Variablen "Jahr".

Und die Funktion, die mit der globalen Variablen "Jahr" rechnet, rechnet immer mit vierstelligen Jahreszahlen, weil die Variable Jahr durch Auslesen der RTC wie folgt erzeugt wird:
Code:
Jahr      = bcdToDec(Wire.read() ) + 2000;

Eine Berechnung mit einer zweistelligen Jahreszahl sehe ich nicht.
Also wieso soll es ein Problem geben? Und welches Problem genau, hast Du ein Beispiel?

Und warum werden die Funktionsvariablen year, month, day und hour in der IDE rot dargestellt?
Würde doch bedeuten, diese Namen werden von der IDE intern schon verwendet?

Das bedeutet, dass Du irgendeine Library installiert hast, die diese Variablennamen als Keywords deklariert hat. Ob diese Namen für irgendwas anderes auch tatsächlich verwendet werden, darüber sagt das nichts aus. Das sagt nur aus, dass Du gerade ein Keyword hingeschrieben hast. Der Arduino-Editor ist recht trivial gestrickt.

8  International / Deutsch / Re: lcd.createChar für mehr als 8 Zeichen? on: April 19, 2014, 07:47:51 am
Der Zeichensatz eines Text-Displays besteht aus 256 Zeichen.
Davon kannst Du 8 Zeichen selbst definieren und 248 Zeichen sind "fest" im Zeichenspeicher vorprogrammiert.

Die 8 Zeichen, die Du selbst definieren kannst, kannst Du beliebig oft ändern.

Du kannst z.B. mit einer neunten Definition eines Zeichens das erste früher selbstdefinierte Zeichen wieder mit einer anderen Definition überschreiben.

Aber Du hast zu jedem Zeitpunkt nur 8 selbstdefinierte Zeichen.

Wenn Du künstlerisch tätig werden möchtest, nimm ein Grafik-Display anstelle eines Text-Displays!
9  International / Deutsch / Re: Windmesser auslesen on: April 18, 2014, 02:07:27 pm
Ein Beispiel-Code wäre total cool. Wenn Du das auf die Schnelle machen könntest, wäre ich Dir unsagbar dankbar.

Du möchtest das aber nicht bereits für ein Oster-Sportfest am Laufen haben, oder?

Ich weiß auch nicht ganz genau, was Du genau machen möchtest und wie die Daten dann weiterverarbeitet werden sollen.

Ich habe auf die schnelle was zusammenkopiert und geschrieben, das wie folgt arbeitet:

LED als "Bereitschaftsanzeige":
Wenn der Sketch bereit ist zur Messung, wird die Board LED an Pin-13 eingeschaltet.
Während eine Messung läuft, ist die Board LED an Pin-13 ausgeschaltet

Der Sketch versucht, immer die beiden Werte aus je 3 Zeilen auszulesen und gibt im Erfolgsfall aus:
- Zeitstempel beim Empfang von Wert-1
- Wert-1 als String, so wie er empfangen wurde
- Wert-1 umgewandelt in eine numerische Gleitkommavariable
- Wert-2 als String, so wie er empfangen wurde
- Wert-2 umgewandelt in eine numerische Gleitkommavariable
- Zeitstempel beim Empfang von Wert-2

Der numerische Wert weicht vom tatsächlichen Wert mindestens in dem Fall ab, dass "--.-" empfangen wird, dann ist der empfangene Wert "--.-" und der numerische Wert "0.0".

Die Zeitstempel stammen hier einfach vom Stand des millis() Timers (Zeit seit Controller-Reset), könnte man bei Bedarf aber auch aus einer Echtzeituhr ziehen.

Falls eine Messung begonnen wurde, aber während einer bestimmten Timeout-Dauer keine weiteren Zeichen empfangen wurden, erfolgt ein Fallback in Messbereitschaft und das Programm wartet auf eine neue Messung. Diese Timeout-Zeit habe ich mal auf 60 Sekunden eingestellt.

Wenn die Messwerte irgendwo in einem seriellen Terminalprogramm mitgeloggt werden sollen, kann man das wohl so ungefähr machen. Aber falls die Daten irgendwie weiter verarbeitet werden sollen, müßte man an der Struktur vielleicht irgendwas ändern.

Probiers mal aus.

Code:
#define LED 13  // Pin für LED "Bereitschaftsanzeige"
#define TIMEOUTLIMIT 60000L // Maximaldauer für eine Messung in Millisekunden

char* SerialStringRead(char EOLchar)
{
  // Parameter EOLchar: welches Zeichen als "Zeilenende" interpretiert werden soll
  // Rückgabewert: Wenn keine Zeile gelesen wurde NULL, sonst String-Pointer
  static char text[25]; // Stringpuffer für maximale Zeilenlänge + 1
  static byte charcount=0; // Zeichenzähler
  if (!Serial.available()) return NULL; // kein Zeichen im seriellen Eingangspuffer
  if (charcount==0) memset(text,0,sizeof(text)); // Stringpuffer löschen
  char c=Serial.read(); // ein Zeichen aus dem seriellen Eingangspuffer lesen
  if (c>32 && charcount<sizeof(text)-1) // Steuerzeichen und Leerzeichen überlesen
  {
    text[charcount]=c; // ASCII-Zeichen > 32 behalten
    charcount++;
  }
  else if (c==EOLchar)
  {
    charcount=0;
    return text;
  }
  return NULL;
}

boolean timeoutErkennung(boolean doReset)
{
  static unsigned long lastCharReceived=0;
  if (doReset)  // Timeout resetten
    lastCharReceived=millis();
  else  // Timeout prüfen
  {
    if (millis()-lastCharReceived>TIMEOUTLIMIT) return true;
  }
  return false;
}




void setup() {
  Serial.begin(9600);
  pinMode(LED,OUTPUT);
  Serial.println("Alge-Timing Windmesser WS2 auswerten by 'jurs' for German Arduino Forum");
  Serial.println();
  Serial.println("Zeit  \tWert-1\tW1 num\tWert-2\tW2 num\tZeit  ");
  Serial.println("------\t------\t------\t------\t------\t------");
}


byte linecount=0;
float wert1,wert2;

void loop()
{
  char* strPtr;
  if (Serial.available())
  {
    timeoutErkennung(true); // Timeout resetten
    strPtr=SerialStringRead(13); // Zeichen auslesen
  }
  else strPtr=NULL;
  if (strPtr!=NULL && strcmp(strPtr,"")==0)
  {// Auf Leerzeile synchronisieren, normalerweise die dritte Zeile nach zwei Datenwerten
    Serial.println();
    linecount=0;
  }
  else if (strPtr!=NULL)
  {
    linecount++;
    switch (linecount)
    {
      case 1:
        Serial.print(millis()/1000.0,1); // Zeit für den ersten Wert
        Serial.print('\t');
        Serial.print(strPtr); // Erster Wert als String
        Serial.print('\t');
        wert1=atof(strPtr);   // Erster Wert numerisch
        Serial.print(wert1);
        Serial.print('\t');
        break;
      case 2:
        Serial.print(strPtr);  // Zweiter Wert als String
        Serial.print('\t');
        wert2=atof(strPtr);
        Serial.print(wert2);   // Zweiter Wert numerisch
        Serial.print('\t');
        Serial.print(millis()/1000.0,1); // Zeit für den zweiten Wert
        break;
    }
  }
  if (linecount==0) digitalWrite(LED,HIGH); // in Bereitschaft auf Messung warten, Bereitschaftsanzeige an
  else  // wir sind mitten in einer Messung
  {
    digitalWrite(LED,LOW);  // Bereitschaftsanzeige aus
    if (timeoutErkennung(false)) // Auf Timeout prüfen, falls Timeout wieder in Bereitschaft gehen
    {
      Serial.println();
      Serial.println("Timeout - warten auf neue Messung");
      linecount=0;
    }
  }
}
10  International / Deutsch / Re: Windmesser auslesen on: April 18, 2014, 11:36:16 am


Zur Auswertung benötige ich die Werte in den Zeilen 15-18 und 38-41. Für jeden Tipp wäre ich sehr dankbar, versuche mich aber auch weiter selbst daran, die Werte zur Auswertung zu bringen.

Sieht doch sehr gut aus!

Ein Datensatz besteht offenbar immer aus drei Zeilen gleicher Länge, die jeweils 22 Zeichen enthalten und mit dem Zeilenendezeichen ASCII-13 abgeschlossen werden.

Zeilenende ASCII-13 in den Bytes Nummer 23, 46 und 69.
Die ersten beiden Zeilen enthalten außer Leerzeichen (ASCII-32) nur die von Dir gesuchten Daten.
Die dritte Zeile ist (bis auf Leerzeichen) komplett leer.

Da läßt sich eine schöne Programmlogik drumherum bauen, die sich sogar selbständig synchronisieren kann: Immer nachdem eine leere Zeile empfangen wurde, beginnt (irgendwann) eine neue Messung.

Wenn man da noch ein Timeout drum herumbaut, so dass falls "Matschzeichen" auf der Leitung auftreten (z.B. jemand stolpert über das Kabel, Stecker reißt raus, Stecker wird wieder reingesteckt und erzeugt "falsche" Zeichen), eine Fehlmessung nach einer gewissen Zeit mit "Timeout" beendet und auf eine neue Messung gewartet wird, wird es nicht nur selbstsynchronisierend, sondern das Ganze auch "fail safe".

Brauchst Du Beispielcode?

Den ersten RS232-TTL Adapter hast Du durch Falschanschluss erfolgreich ruiniert und nun den zweiten in Gebrauch?

Hast Du auch darauf geachtet, ggf. mit dem Multimeter ausgemessen, dass dieser Adapter auch wirklich nur 3.3V Pegel auf der TTL-Seite ausgibt? Weil mit dem "DUE" hast Du Dir ja ein empfindliches 3.3V 32-Bit Board geholt, und nicht eines mit einem robusten 8-Bit 5V Controller. Nicht, dass Du Dir nach dem Adapter durch Falschanschluss nun als nächstes das DUE-Board durch zu Überspannungspegel an Serial1 ruinierst.
11  International / Deutsch / Re: Zeitmessung mit Lichtschranke on: April 18, 2014, 09:40:40 am
Code:
while(val<70) {
    1;
}

Das ist eine Endlosschleife, sobald die Bedingung erfüllt ist.
Denn das Ergebnis (val<70) ändert sich innerhalb der Schleife niemals mehr, so daß gilt: Einmal erfüllt, immer erfüllt.
12  International / Deutsch / Re: Zeitgesteuertes Loggen auf SD Karte on: April 18, 2014, 09:29:18 am
Lässt sich das exakt lösen, ich denke da an einen Interrupt? Also das jede Aufzeichung exat bei t1=50 ms; t2 =100 ms; t3 = 150 ms; t4 = 200 ms;

Und wenn ja, wie muss das dann grob aussehen? (Noch nie benutzt)

Grob gesagt benötigst Du einen Timer-Interrupt und und einen FIFO-Ringpuffer.

Drei Schritte:

1. Den Timer-Interrupt programmierst Du so, dass er alle 50 ms läuft.

2. Innerhalb der Interrupt-Behandlungsroutine machst Du die Messung und schiebst den Messwert in den FIFO-Ringpuffer.

3. Innerhalb der loop-Funktion schaust Du laufend nach, ob Daten im FIFO drin sind, und wenn ja, dann schreibst Du diese Daten auf SD-Karte weg.

P.S.: "Messungen" sind dabei natürlich auf solche Art Messungen beschränkt, die ohne die Verwendung von Interrupts funktionieren, damit sie innerhalb einer Interrupt-Behandlungsroutine laufen können.
13  International / Deutsch / Re: non-blocking function mit millis() on: April 18, 2014, 08:10:36 am
nö im Grunde reiche Sekunden, da Magnetventile für die Gartenbewässerung angesteuert werden...also Werte so im Bereich 300 - 3600

OK, ich habe da mal ein nichtblockierendes Demoprogramm erstellt:
Code:

byte relaisPins[]={10,11,12,13};
#define anzahlRelais sizeof(relaisPins)
long relaisZeiten[anzahlRelais];
unsigned long relaisZyklusStart;
#define EIN HIGH
#define AUS LOW


char* SerialStringRead(char EOLchar)
{
  // Parameter EOLchar: welches Zeichen als "Zeilenende" interpretiert werden soll
  static char text[81]; // Stringpuffer für maximale Zeilenlänge + 1
  static byte charcount=0; // Zeichenzähler
  if (!Serial.available()) return NULL; // kein Zeichen im seriellen Eingangspuffer
  if (charcount==0) memset(text,0,sizeof(text)); // Stringpuffer löschen
  char c=Serial.read(); // ein Zeichen aus dem seriellen Eingangspuffer lesen
  if (c>=32 && charcount<sizeof(text)-1)
  {
    text[charcount]=c;
    charcount++;
  }
  else if (c==EOLchar)
  {
    charcount=0;
    return text;
  }
  return NULL;
}

void showStatus()
{
  // gesetzten Schaltstatus der Relais anzeigen
  Serial.print(millis()/1000); // Zeit seit Controllerstart in Sekunden
  Serial.print('\t');
  for (int i=0;i<anzahlRelais;i++)
  {
    if (digitalRead(relaisPins[i])==EIN)
      Serial.print("EIN\t");
    else
      Serial.print("AUS\t");
  }
  Serial.println();
}


void relaisAbSchaltenNachZeit()
{
  for (int i=0;i<anzahlRelais;i++)
  {
    if (relaisZeiten[i]>0 && millis()-relaisZyklusStart>relaisZeiten[i]*1000L)
    {
      relaisZeiten[i]=0;
      digitalWrite(relaisPins[i],AUS);
      showStatus(); // den neuen Status anzeigen
    }
  }
}

void einSchalten()
{
  // alle Relais  mit einer Schaltzeit>0 einschalten
  for (int i=0;i<anzahlRelais;i++)
  {
    if (relaisZeiten[i]>0) digitalWrite(relaisPins[i],EIN);
    else  digitalWrite(relaisPins[i],AUS);
  }
  relaisZyklusStart=millis(); // neuer Schaltzyklus startet jetzt
  showStatus();
}

void notaus()
{
  // Alle Relais ausschalten
  for (int i=0;i<anzahlRelais;i++)
  {
    relaisZeiten[i]=0;
    digitalWrite(relaisPins[i],AUS);
  }
  Serial.println("Not-Ausschaltung");
  showStatus();
}

void auswerten(char* strPtr)
{
  if (strcmp(strPtr,"S")==0) notaus();
  else
  {
    strPtr=strtok(strPtr,",");
    relaisZeiten[0]=atoi(strPtr);
    strPtr=strtok(NULL,",");
    relaisZeiten[1]=atoi(strPtr);
    strPtr=strtok(NULL,",");
    relaisZeiten[2]=atoi(strPtr);
    strPtr=strtok(NULL,",");
    relaisZeiten[3]=atoi(strPtr);
    // Neue Schaltzeiten anzeigen
    Serial.print("Neue Schaltzeiten: ");
    for (int i=0;i<anzahlRelais;i++)
    {
      Serial.print(relaisZeiten[i]);
      Serial.print('\t');
    }
    Serial.println();
  }
}


void setup() {
  Serial.begin(9600);
  Serial.println("Relais without delay by 'jurs' for German Arduino Forum");
  Serial.println();
  Serial.println("Zeit\tR1\tR2\tR3\tR4\t");
  Serial.println("----\t---\t---\t---\t---\t");
  for (int i=0;i<anzahlRelais;i++)
  {
    if (AUS==HIGH) digitalWrite(relaisPins[i],HIGH);
    pinMode(relaisPins[i],OUTPUT);
  }
  showStatus();
}


void loop()
{
  char* strPtr=SerialStringRead('\n');
  if (strPtr!=NULL)
  {
    auswerten(strPtr);
    einSchalten();
  }
  relaisAbSchaltenNachZeit();
}

Der Code ist so wie er ist für billige "Active LOW" schaltende Relaismodule mit Optokoppler-Eingang vorgesehen, falls Deine Relais stattdessen auf "HIGH" einschalten sollen, ändere den Code auf:
Code:
#define EIN HIGH
#define AUS LOW

Der Trick an nichtblockierendem Code ist, dass er nur auf bestimmte Ereignisse reagiert, z.B. wenn eine bestimmte Zeit  erreicht ist oder ein bestimmtes Zeichen empfangen wurde. Und bis dahin erledigt das Programm nur das, was gerade zu tun ist: Also ein Zeichen verarbeiten, wenn ein Zeichen im seriellen Eingangspuffer verfügbar ist und eine Schaltung am Relais ausführen, wenn eine Schaltung am Relais durchzuführen ist, weil entweder eine bestimmte Zeit erreicht ist oder weil ein neuer Schaltbefehl komplett ist.

Wenn ein Kommando kommt während die Steuerung noch läuft, soll es ignoriert werden AUSSER es handelt sich um das "Abbruchsignal" ('S' im konkreten Fall)

Diese Bedingung ist in meinem Code nicht umgesetzt, sondern im Demoprogramm ist die Programmlogik so, dass durch einen neuen seriellen Befehl während eines noch laufenden Befehls eine Umprogrammierung auf neue Steuerzeiten erfolgt, ab dem Zeitpunkt, an dem der neue Befehl empfangen wird. D.h. alte Restlaufzeiten des letzten Befehls entfallen, ausgeführt werden die neuen Steuerzeiten. Aber das läßt sich an einem so schön modular aufgebauten Demoprogramm ja jederzeit leicht ändern.  smiley-grin

Übrigens: "Not-AUS" ist bei meiner Programmversion einfach auch möglich, indem eine "leere Zeile" gesendet wird. Wenn man eine "leere Zeile" sendet, wird das nämlich jeweils als Steuerzeit von 0 für jedes Relais gewertet, also "keine Zahl gesendet" wird wie "0 gesendet" betrachtet, und daher für auch das Senden einer leeren Zeile umgehend zur Abschaltung, sprich "AUS für Alle". Der Unterschied zu "Aus für Alle" und der richtigen Not-AUS Funktion ist also nur, dass bei richtigen Not-Aus noch eine Not-Aus Meldung auf Serial ausgegeben wird. Aber wie gesagt: Bei so einem modularen Programm kann man natürlich die Logik leicht ändern, wie man es braucht.
14  International / Deutsch / Re: non-blocking function mit millis() on: April 18, 2014, 05:59:45 am
Als Anfänger würde ich mich über Unterstützung bei der Umsetzung und Feedback über etwaige Optimierungsmöglichkeiten freuen!

Sollen auch Sekundenbruchteile unterstützt werden, z.B.
Code:
10.5,20.3,30.456,40.123\n

Oder nur ganze Sekunden?
15  International / Deutsch / Re: Windrichtungsmesser mit 360 Grad Poti, toter Winkel kompensieren ? on: April 18, 2014, 05:02:09 am
Ich habe schon an einen Widerstand vom Ausgang Poti zu Masse gedacht, der Eingang des Arduino wäre dann diesem Bereich definiert.
Nur sind die Meßergebnisse dann nicht mehr linear.

Das ist absolut die richtige Idee.

Du mußt nur den Widerstandswert passend wählen, und zwar "sehr groß gegenüber dem Poti-Widerstand", damit die Messwerte nicht verfälscht werden.

Mal angenommen, Dein Poti im Windrichtungsanzeiger habe 20K Ohm, dann wählst Du den Widerstand zwischen 470K und 1 Mega Ohm.


Pages: [1] 2 3 ... 164