Show Posts
Pages: 1 ... 84 85 [86] 87 88 ... 194
1276  International / Deutsch / Re: Farbverwaltung on: October 25, 2013, 02:38:37 pm
Ich bastele gerade mit den led WS2812B Strips und habe Probleme mit den farb eistellungen

Der hier funktioniert ähnlich: http://www.colorpicker.com/
1277  International / Deutsch / Re: One Wire Problem on: October 25, 2013, 11:56:02 am
Ich kann jetzt nur vermuten aber ich denke das die Versorgung vom Arduino für die Kabelstrecke zu kurz ist bzw. der Kabelquerschnitt zu klein ist.
Gibt es da eventuell eine Lösung oder muss ich ein neues Kabel besorgen?

Miss mal die Stromaufnahme Deiner Schaltung ohne und mit angeschlossenem Sensor!

Ich vermute, Du schließt Deinen Sensor irgendwie "mit eingebautem Kurzschluss" an.
1278  International / Deutsch / Re: Elektronische Futterschublade/Box on: October 25, 2013, 11:48:03 am
Für die Wellenkupplung wie sie da zu sehen ist, brauchst du keinen Nubel, bzw. die Kupplung läuft nur ohne Nubel ruhig.

Allmählich schwant mir, Dein "Nubel" ist eine Passfeder nach DIN-6885?
http://de.wikipedia.org/wiki/Passfeder
1279  International / Deutsch / Re: wind datenspeicher/logger on: October 25, 2013, 10:46:36 am
gespeist wird das ganze durch ne 9v batterie.

Möchtest Du alle 5 bis 10 Stunden eine neue Batterie einsetzen?
Wird das nicht auf Dauer zu teuer? Oder möchtest Du nur Kurzzeitmessungen über wenige Stunden machen?

so nun hab ich mir nen anemometer mit reedkontakt bestellt. is leider noch nicht da , da hab ich vorab aber schon eine frage , ist der schaltungsaufbau wirklich so einfach wie ich ihn mir grad hier zurechtbastel? (anhang)

Den Kondensator würde ich erstmal weglassen und es ohne probieren. Reedkontakte prellen praktisch überhaupt nicht, aber Reedkontakte sind Verschleißteile und Dein Kondensator verhundertfacht oder vertausendfacht den Kontaktverschleiß der Reedkontakte. Dafür würde ich den PullDown-Widerstand allerdings etwas kräftiger vorsehen, z.B. Standardgröße 4.7K, denn es sind ja vermutlich doch einige Meter Kabel zwischen Sensor und Arduino zu überbrücken.

achso muss ich eig auf dem shieldboard die 3,3 v ansteuern oder 5v?

Ein UNO Board läuft mit 5V und seine Digitaleingänge sind auf die Ansteuerung mit 5V ausgelegt. Den Reedkontakt schaltest Du also so, dass er ein 5V Signal am Arduino-Eingang liefert.

die sd läuuft ja mit 3,3 v , dann muss ich da noch was zwischenhängen?!

Ja, die SD läuft auf 3.3V. Wenn das ein "Shield mit SD-Kartenschacht" ist, sollte die komplette notwendige Beschaltung der SD-Karte auf dem Shield enthalten sein, also insbesondere ein 3.3V Spannungswandler zur Spannungsversorgung der SD-Karte sowie die notwendigen Pegelwandler, so dass keine zusätzliche Beschaltung mehr notwendig sein sollte.

ps sorry für das bild, isn eckchen zu groß smiley-sad

A fault confessed is half redressed.
1280  International / Deutsch / Re: millis()-Glaubensfrage on: October 25, 2013, 10:17:52 am
Ich glaube, das ist kein Unterschied, würde das aber eher so machen:

Es macht beim Timen von Intervallen mit Hilfe der millis() Funktion keinen Unterschied bei Programmen, die weniger als 25 oder 50 Tage am Stück laufen, bevor sie resettet werden.

Wenn man Programme schreibt, die korrekte Intervalle auch bei Sketch-Laufzeiten von mehr als 50 Tagen am Stück einhalten sollen, und zwar bei allen Intervallen, auch über den Überlauf des Timers hinweg, der muß sich an bestimmte Standards halten.
1281  International / Deutsch / Re: millis()-Glaubensfrage on: October 25, 2013, 09:13:54 am
ist es lediglich eine Glaubensfrage, was "man" verwenden sollte?  smiley-roll

Code:
if(millis()-intervall>letzter_zeitpunkt)

if(millis()>letzter_zeitpunkt+intervall)

Was sind denn das für Alternativen, wenn Du die Wahl zwischen Pest und Cholera anbietest?

Korrekt natürlich:
Code:
if(millis()-letzter_zeitpunkt>=intervall)
1282  International / Deutsch / Re: Fragen zum Design einer LED Uhr on: October 25, 2013, 08:36:49 am
Meine Frage bezieht sich jetzt darauf, ob die Stromversorgung per Batterie dazu ausreicht

Rechne es Dir aus, Du benötigst die Batteriekapazität in "Ah" und die Stromaufnahme Deiner Schaltung in "A" oder wahlweise auch die Batteriekapazität in "mAh" und die Stromaufnahme in "mA". Dann rechnest Du:

Ungefähre Batterielaufzeit in Stunden = Batteriekapazität geteilt durch Stromaufnahme

Un schon weißt Du, ob ein Batteriewechsel alle halbe Stunde, alle 2 Stunden oder sogar erst alle 5 oder 10 Stunden fällig ist. Oder wie oft auch immer dabei herauskommt.
1283  International / Deutsch / Re: I2c LCD Zeilenverhalten komisch on: October 24, 2013, 01:22:13 pm
woran kann dies liegen?

Da versucht wahrscheinlich irgendein Komiker, auf einem Display mit 20 Zeichen pro Zeile mehr als 20 Zeichen in einer einzigen Zeile auszugeben. Und dann wird's komisch.
1284  International / Deutsch / Re: Mega8 USB-Seriell Konverter on: October 24, 2013, 01:10:55 pm
Da ich aber auch im Besitz eines Arduino Mega 2560 bin ist mir aufgefallen das die USB-Seriell Umsetzung dort mittels eines Mega8 umgesetzt wurde.

Atmega8 != Atmega8U2
1285  International / Deutsch / Re: String und float-Zahl seriell einlesen! on: October 24, 2013, 08:16:57 am
Sieht für mich erstmal ziemlich kompliziert aus smiley

An der Anzahl der Funktionen kann es eigentlich nicht liegen, da sind nur drei Stück relevant
- eine Funktion zum Einlesen einer Zeile
- eine Funktion zum Lernen von Variableninhalten
- eine Funktion zum Ausliefern von Variableninhalten
Das kann man an den Fingern einer Hand abzählen.

Was vielleicht kompliziert ist, ist der Umgang mit C-Strings, C-String-Funktionen und Pointern. Das ist natürlich etwas gewöhnungsbedürftig.

-es soll 3 feste Eingabebefehle geben
 z.B. Wert1_float Zahlenwert
         Wert2_float Zahlenwert
         Wert3_float Zahlenwert
  und es soll leider alles in einer Eingabezeile eingelesen werden.

Du solltest vielleicht mal prüfen, ob überhaupt jedesmal "Namen" mit übertragen werden müssen, oder ob es nicht ausreicht, nur die "Werte" zu übertragen. Wenn nämlich immer alle drei (und immer dieselben) Namen mit immer drei (zu denselben Namen gehörenden) Werten übertragen werden, dann kannst Du die Namen auch weglassen.

Statt:
wert1_47.12 wert2_47.13 wert3_47.14
überträgst Du einfach
47.12 47.13 47.14
Und dann ordnest Du drei in einer Zeile ankommenden Werten in Deinem Sketch die passenden Variablen zu.

Wenn Du es auch vertauscht auswerten möchtest, also z,B.:
wert2_47.13 wert1_47.12 wert3_47.14
oder es fehlt mal ein Wert:
wert2_47.13 wert3_47.14
oder es stehen auch "falsche Namen" in einer Zeile dabei, die unberücksichtigt bleiben sollen:
wert5_47.12 wert4_47.13 wert3_47.14 wert1_47.12 wert2_47.13
dann wird die Auswertung natürlich komplexer als wenn einfach nur drei Zahlen in immer derselben Anzahl und Reihenfolge zu erfassen sind.

-sagen wir die float Zahl benötigt etwa 5 Ziffern nach dem Komma

Die einfach genauen Gleitkommazahlen von AVR GCC haben überhaupt nur 6-7 signifikante Stellen. Wenn Du also fünf Stellen nach dem Komma brauchst, dann darf die Zahl nur eine einzige Stelle vor dem Komma haben, wenn sie sie unter allen Umständen zuverlässig reproduzierbar als "float" speichern möchtest.
1286  International / Deutsch / Re: GPS Modul ansteuern mit GPS Libary Problem on: October 23, 2013, 06:27:40 am
Okay, mit besonders genauen Angaben kann ich also nicht rechnen.
Wenn ich die Funktion gps.f_altitude(); verwende bekomme ich aber immer nur 10000 zurückgegeben.

Wenn Du ernsthaft etwas mit einem GPS-Empfänger machen möchtest, müßtest Du davon weggkommen, die "SoftwareSerial" Library zu verwenden, die mit der Arduino-Software mitgeliefert wird. Das Ding ist so grausam, das produziert in praktisch jedem Sketch, den ich damit ausprobiert habe, immer wieder Fehler beim Datenempfang.

Hast Du vielleicht ein Board zur Verfügung, das mehr als eine hardwaremäßig vorhandene serielle Schnittstelle unterstützt, z.B. einen MEGA?

Wenn nicht, dann installiere Dir mal eine "alternative" Library, um eine SoftwareSerial-Schnittstelle bereitzustellen, z.B. diese hier:
http://www.pjrc.com/teensy/td_libs_AltSoftSerial.html

Dann schreibe Deinen Sketch um, damit statt SoftwareSerial die Library AltSoftSerial verwendet wird.

Nachtrag: Ich habe selbst gerade mal mit AltSoftSerial auf einem UNO getestet, damit läuft es einwandfrei.

Geänderter Test-Sketch für GPS-Module auf 9600 Baud und den seriellen Monitor auf 38400 Baud laufend:
Code:
// #include <SoftwareSerial.h>
#include <AltSoftSerial.h>

#include <TinyGPS.h>

/* This sample code demonstrates the normal use of a TinyGPS object.
   It requires the use of SoftwareSerial, and assumes that you have a
   4800-baud serial GPS device hooked up on pins 4(rx) and 3(tx).
*/

TinyGPS gps;
// SoftwareSerial ss(4, 3);
AltSoftSerial ss; // with Uno use RX=8, TX=9 only!

static void smartdelay(unsigned long ms);
static void print_float(float val, float invalid, int len, int prec);
static void print_int(unsigned long val, unsigned long invalid, int len);
static void print_date(TinyGPS &gps);
static void print_str(const char *str, int len);

void setup()
{
  Serial.begin(38400);
  
  Serial.print("Testing TinyGPS library v. "); Serial.println(TinyGPS::library_version());
  Serial.println("by Mikal Hart");
  Serial.println();
  Serial.println("Sats HDOP Latitude  Longitude  Fix  Date       Time     Date Alt    Course Speed Card  Distance Course Card  Chars Sentences Checksum");
  Serial.println("          (deg)     (deg)      Age                      Age  (m)    --- from GPS ----  ---- to London  ----  RX    RX        Fail");
  Serial.println("-------------------------------------------------------------------------------------------------------------------------------------");

  ss.begin(9600);
}

void loop()
{
  float flat, flon;
  unsigned long age, date, time, chars = 0;
  unsigned short sentences = 0, failed = 0;
  static const double LONDON_LAT = 51.508131, LONDON_LON = -0.128002;
  
  print_int(gps.satellites(), TinyGPS::GPS_INVALID_SATELLITES, 5);
  print_int(gps.hdop(), TinyGPS::GPS_INVALID_HDOP, 5);
  gps.f_get_position(&flat, &flon, &age);
  print_float(flat, TinyGPS::GPS_INVALID_F_ANGLE, 10, 6);
  print_float(flon, TinyGPS::GPS_INVALID_F_ANGLE, 11, 6);
  print_int(age, TinyGPS::GPS_INVALID_AGE, 5);
  print_date(gps);
  print_float(gps.f_altitude(), TinyGPS::GPS_INVALID_F_ALTITUDE, 7, 2);
  print_float(gps.f_course(), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
  print_float(gps.f_speed_kmph(), TinyGPS::GPS_INVALID_F_SPEED, 6, 2);
  print_str(gps.f_course() == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(gps.f_course()), 6);
  print_int(flat == TinyGPS::GPS_INVALID_F_ANGLE ? 0xFFFFFFFF : (unsigned long)TinyGPS::distance_between(flat, flon, LONDON_LAT, LONDON_LON) / 1000, 0xFFFFFFFF, 9);
  print_float(flat == TinyGPS::GPS_INVALID_F_ANGLE ? TinyGPS::GPS_INVALID_F_ANGLE : TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
  print_str(flat == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON)), 6);

  gps.stats(&chars, &sentences, &failed);
  print_int(chars, 0xFFFFFFFF, 6);
  print_int(sentences, 0xFFFFFFFF, 10);
  print_int(failed, 0xFFFFFFFF, 9);
  Serial.println();
  
  smartdelay(1000);
}

static void smartdelay(unsigned long ms)
{
  unsigned long start = millis();
  do
  {
    while (ss.available())
      gps.encode(ss.read());
  } while (millis() - start < ms);
}

static void print_float(float val, float invalid, int len, int prec)
{
  if (val == invalid)
  {
    while (len-- > 1)
      Serial.print('*');
    Serial.print(' ');
  }
  else
  {
    Serial.print(val, prec);
    int vi = abs((int)val);
    int flen = prec + (val < 0.0 ? 2 : 1); // . and -
    flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
    for (int i=flen; i<len; ++i)
      Serial.print(' ');
  }
  smartdelay(0);
}

static void print_int(unsigned long val, unsigned long invalid, int len)
{
  char sz[32];
  if (val == invalid)
    strcpy(sz, "*******");
  else
    sprintf(sz, "%ld", val);
  sz[len] = 0;
  for (int i=strlen(sz); i<len; ++i)
    sz[i] = ' ';
  if (len > 0)
    sz[len-1] = ' ';
  Serial.print(sz);
  smartdelay(0);
}

static void print_date(TinyGPS &gps)
{
  int year;
  byte month, day, hour, minute, second, hundredths;
  unsigned long age;
  gps.crack_datetime(&year, &month, &day, &hour, &minute, &second, &hundredths, &age);
  if (age == TinyGPS::GPS_INVALID_AGE)
    Serial.print("********** ******** ");
  else
  {
    char sz[32];
    sprintf(sz, "%02d/%02d/%02d %02d:%02d:%02d ",
        month, day, year, hour, minute, second);
    Serial.print(sz);
  }
  print_int(age, TinyGPS::GPS_INVALID_AGE, 5);
  smartdelay(0);
}

static void print_str(const char *str, int len)
{
  int slen = strlen(str);
  for (int i=0; i<len; ++i)
    Serial.print(i<slen ? str[i] : ' ');
  smartdelay(0);
}
Arduino RX-Pin kann mit AltSoftSerial nicht frei ausgewählt werden, sondern mit AltSoftSerial ist beim UNO RX fest auf Pin-8, also TX vom GPS-Modul mit RX Pin-8 am UNO verbinden.

Aber achte mal im Vergleich zu SoftwareSerial auf die Spalte "Checksum Fail". Mit SoftwareSerial kannst Du zusehen, wie "Checksum Fail" von Sekunde zu Sekunde größer wird, so viele Datenfehler verursacht die SoftwareSerial Library. Mit der AltSoftSerial Library bleibt "Checksum Fail"  ganz stabil bei "0" stehen.

Höhenangaben werden übrigens nicht immer mitgeliefert, sondern nur dann, wenn kein "2D fix" vom GPS-Modul geliefert wird, sondern ein "3D fix".  Das muß man nicht extra umschalten, sondern das Modul liefert einfach: Bei schlechtem Empfang kommen 2D fix Datensätze ohne Höhenangaben, bei besserem Empfang 3D fix Datensätze mit Höhenangaben. Die TinyGPS-Library kann meines Wissens nach nicht auswerten, ob 2D oder 3D Daten kommen. Als Anhalt kann Dir aber die Anzahl der Satelliten dienen, die TinyGPS anzeigt: Mit 0, 1 oder 2 Satelliten bekommst Du überhaupt keine Positionsangaben, mit 3 Satelliten bekommst Du Längen- und Breitengradangaben, und mit 4 oder mehr Satelliten bekommst Du auch Höhenangaben mitgeliefert. So als grober Anhalt "über den Daumen gepeilt", ohne dass man direkten Zugriff auf alle gelieferten Daten hat, sondern nur die paar minimalen Daten, die die TinyGPS-Library von den gelieferten Daten auswerten kann.
1287  International / Deutsch / Re: String und float-Zahl seriell einlesen! on: October 23, 2013, 05:26:38 am
Habe schonmal ein bisschen rumprobiert, aber bisher ohne Erfolg.

Schön, dass Du schon mal selbst probiert hast, denn Programmieren lernt man nur durch Programmieren.

Allerdings scheinen Dir ganz wesentliche Grundkenntnisse zu über Programmierung allgemein und die Programmierung in C im besonderen zu fehlen. Und darüber hinaus läßt Du Dich von den Arduino-Machern völlig in die Irre leiten.

Erstens mal "String": Die Arduino-Macher propagieren aus mir völlig unerfindlichen Gründen "String-Objekte", die so deklariert werden:
  String Eingabebefehl;
Diese String-Objekte sind der letzte Dreck. Erstens verbrauchen die viel zu viel RAM-Speicher, wenn man sie verwendet. Zweitens sind sie kaum in irgendeiner brauchbaren Form kompatibel zur C-String Implementation der Standard-Library des GCC-Compilers. Standardmäßig arbeiten C-Compiler mit C-Strings, das sind einfach char-Arrays. Sämtliche Funktionen der GCC-Standardlibrary mit dem Namen "AVR libc" arbeiten nur und ausschließlich mit C-Strings und NICHT mit String-Objekten. Es handelt sich bei der "AVR libc" um eine sehr mächtige Library, und gegen das, was die AVR libc Library an Funktionen zur Stringbehandlung und Stringumwandlung bietet, sind die handvoll "Komfortfunktionen" für String-Objekte ein lächerlicher Witz. Die Dokumentation der kompletten "AVR libc" findest Du hier:
http://www.nongnu.org/avr-libc/user-manual/modules.html

Wenn Du ernsthaft mit Arduino programmieren möchtest, solltest Du schon so 10 bis 20 Funktionen dieser Library anwenden können (insgesamt sind es hunderte Funktionen).

Zweitens mal: Das wichtige sind beim Programmieren nicht nur die Algorithmen, also was wie programmiert und manipuliert wird, sondern ganz wichtig ist es zu Anfang, sich geeignete DATENSTRUKTUREN zu überlegen. Denn am Ende hängt es an den Datenstrukturen, wie diese be- und verarbeitet werden können.

Und Drittens mal: Wenn Du eine komplexe Aufgabe hast, zerlege sie in sinnvolle und kleinere Teilaufgaben. Und mache für jede Teilaufgabe eine Funktion.

Hast du dafür mal ein zusammenhängendes Codebeispiel?

Ich habe mal für Deinen Fall ein  Codebeispiel gemacht, und mir dazu folgendes überlegt:

1. Datenstrukturen
Ich habe mir überlegt, dass Du eine bestimmte Anzahl verschiedener "Wertenamen" verwalten möchtest, für die jeweils ein "Wert" gespeichert werden soll. Dazu habe ich mir überlegt, diese jeweils als C-Strings zu verwalten, mit einer Länge von 8 (7 Zeichen plus das Nullzeichen, das bei C-Strings für das Ende des Strings steht).  Im Beispiel gibt es drei verschiedene "wert", "abc" und "def", falls mehr als drei benötigt werden, kann man das in der Datenstruktur leicht anpassen:

#define STRLEN 8 // Maximale Länge der Strings (inkluse Nullzeichen am Ende)
#define STRNUM 3 // Anzahl der Strings
char strings[STRNUM][STRLEN]={"wert","abc","def"};
char values[STRNUM][STRLEN];

Durch die Deklaration eines zweidimensionalen Char-Arrays deklarierst Du nicht ein "Array of chars" als einen C-String, sondern ein "Array of Array of chars", also ein "Array of C-Strings".

Ich bin mal davon ausgegangen, dass Du mehr als nur eine Variable "wert" verwalten möchtest, sondern es mehrere verschiedene werden.

2. Teilaufgaben
Als zu erledigende Teilaufgaben habe ich mir überlegt:
- eine serielle Zeile komplett einlesen
- wenn die Zeile komplett empfangen wurde nachsenen:
- ist ein "_" in der Zeile enthalten ==> Funktion aufrufen zum "Lernen"  des Werts
- ist ein "?" in der Zeile enthalten ==> Funktion aufrufen zum "Zurückliefern" des Werts

3. Alle Teilaufgaben in eine eigene Funktion "serialTask();" packen, die dann aus der loop heraus aufgerufen wird.

Code:
#define STRLEN 8 // Maximale Länge der Strings (inkluse Nullzeichen am Ende)
#define STRNUM 3 // Anzahl der Strings
char strings[STRNUM][STRLEN]={"wert","abc","def"};
char values[STRNUM][STRLEN];

char* receiveBuffer()
#define ZEILENTRENNZEICHEN 13   // 13 ist Steuerzeichen CR (Carriage Return)
{
  static char lineBuffer[25]; // Maximale Zeilenlänge festlegen
  static byte counter=0;
  char c;
  if (Serial.available()==0) return NULL; // Nullpointer zurück
  if (counter==0) memset(lineBuffer,0,sizeof(lineBuffer));// Puffer vor Benutzung löschen
  c=Serial.read();
  if (c==ZEILENTRENNZEICHEN)
  {
    counter=0;
    return lineBuffer;
  }
  else if (c>=32) // kein Steuerzeichen?
  {
    lineBuffer[counter]=c; // Zeichen im Zeilenpuffer einfügen
    if (counter<sizeof(lineBuffer)-2) counter++;
  }
  return NULL;
}

void setup()
{
  Serial.begin(9600);
}

void learnValue(char* str, char* val)
{
  for (int i=0;i<STRNUM;i++)
  {
    char* found=strstr(str,strings[i]);
    if (found==str)
    {
      strncpy(values[i],val,STRLEN);
//      Serial.println(values[i]);
    }
  }  
}

char* returnValue(char* str)
{
  for (int i=0;i<STRNUM;i++)
  {
    char* found=strstr(str,strings[i]);
    if (found==str)
    {
//      Serial.println(values[i]);
      return values[i];
    }
  }
  return NULL;  
}

void serialTask()
{
  char* string;
  char* value;
  char* text=receiveBuffer();
  if (text==NULL) return;
  // Testen auf "_"
  string=strtok(text,"_");
  value =strtok(NULL,"_");
  if (value!=NULL) learnValue(string,value);
  // Testen auf "?"
  if (strchr(text,'?')!=NULL)
  {
    value=returnValue(string);
    if (value==NULL)
      Serial.println("Value not found");
    else
    {  
      Serial.print("Value for ");
      Serial.print(text);
      Serial.print(" is: ");
      Serial.println(value);
    }
  }  
}

void loop()
{
  serialTask();  
}

Hinweise:
Bei der Eingabe des Wertenamens kommt es auf die Groß- und Kleinschreibung an, d.h. wenn der Wertename "wert" deklariert ist, wird er in derselben Schreibweise erwartet, und "wert", "Wert", "wErt" etc. wären verschiedene Wertenamen.

Wernn Du die "Werte" nicht als Strings benötigst, sondern als Gleitkommazahlen, hilft die AVR libc "atof()" bei der Umwandlung von C-String ("array of chars")  nach float. Der Funktionsname "atof" steht dabei als Kurzbegriff für "array to float", als kleine Merkhilfe, was die Funktion macht:
http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html#ga689c9d3c4c04463aa31d329937789d06

P.S.: Der Demo-Code macht reichlich Gebrauch von char-Pointern, das sind im Prinzip Zeiger auf ein char-Array, das seine Speicherinhalte an anderer Stelle haben. Kurze Erläuterungen im Kommentar:
char lineBuffer[25]; // Ein char-Array mit 25 reservierten Stellen im RAM-Speicher
char* text; // Ein "Zeiger auf ein char Array" (ohne reservierten Speicher)
Char-Zeiger (Pointer) sind nützlich, da sie in vielen Fällen von Standardfunktionen als Rückgabewert zurückgeliefert werden, z.B. von Suchfunktionen.  Ein spezieller char-Pointer ist dabei die Konstante "NULL", die auf "keine Speicherstelle" verweist, z.B. wenn eine Suchfunktion "nicht gefunden" zurückliefert.
1288  International / Deutsch / Re: Temperaturberechnung mittels NTC-Widerstand on: October 22, 2013, 04:21:08 pm
Wenn der NTC mit Wärmeleitpaste an einem "unendlich" großen Stück Kupfer-Rohr mit warmem Wasser drin befestigt ist, dessen Temperatur er messen soll, glaube ich einfach nicht, dass der Sensor, das Rohr und das ganze Wasser mit meinen 1.3 mW messbar erwärmt werden...

Ja, auch meiner Meinung nach beziehen sich die Datenblattwerte des Herstellers wohl kaum auf Deine speziellen Applikation mit Wärmeleitpaste und Kupfer-Rohren. Wenn im Datenblatt steht "Eigenerwärmung 1,2 mW / K, Ansprechzeit 15s in stehender Luft" dann würde ich vermuten, dass sich auch die Eigenerwärmung auf den Betriebszustand "in stehender Luft" bezieht.
1289  International / Deutsch / Re: Höhen- und Entfernungsmessung. Wie am besten realisieren? on: October 22, 2013, 03:47:44 pm
Mein BMP085 ist eingetroffen. Und ich bin zu tiefst enttäuscht... Drei Stunden Höhendaten geloggt ohne das Board zu berühren und was kommt raus? Differenzen von über 6 Metern... Wieso? Taugt der Sensor doch nichts für mein Projekt?

Das ist vollkommen normal.

Kannst Du Dich erinnern, dass ich ganz am Anfang des Threads das gefragt habe:
Frage: Wie lang ist die typische/maximale Messdauer zwischen dem Zeitpunkt, an dem der Startknopf gedrückt wird, bis am Ziel der Alarm "maximaler Druckunterschied erreicht" ausgelöst werden soll?

Die "Zeit" ist ein ganz entscheidender Faktor wie ich auch versuchte zu erklären.
Der Luftdruck ändert sich (ständig!) mit dem Wetter, mal haben wir Tiefdruck und mal haben wir Hochdruck, dazwischen schwankt der Luftdruck. Mal mehr, mal weniger. Und diese Schwankungen werden zwangsläufig in Höhenänderungen umgerechnet, das ist bei barometrischen Höhenmessern unvermeidlich.

Was Du also tun mußt für eine hohe Genauigkeit:
- Entweder Du hältst die Messdauer kurz (z.B. 15 Minuten), so dass innerhalb der Messzeit keine großen Luftdruckänderungen auftreten.
- Oder Du berücksichtigst die meteoroligischen Luftdruckschwankungen, etwa indem Du von einer ortsfesten Luftdruckstation in Deiner Nähe die Werte "Luftdruck bei Messbeginn" und "Luftdruck nach Zeit x" berücksichtigen kannst. Das wird ohne eine aktive Internetanbindung aber kaum möglich sein.

Natürlich kannst Du auch "Schätzwerte" für die Luftdruckänderung als Parameter für das Skript vorsehen, also dass Du beispielsweise beim DWD die Luftdruckänderung der letzten Stunde im Internet abfragst und dann einfach so tust, als würde die aktuelle Luftdruckänderungsrate identisch sein zur Luftdruckänderungsrate der vergangenen Stunde.

Oder Du siehst einen "Kalibriermodus vor": Im Kalibriermodus muß das Gerät z.B. 10 Minuten an Ort und Stelle liegen gelassen werden, das Gerät ermittelt dabei (grob) die aktuelle Luftdruckänderungsrate und bei der anschließenden Messung wird diese Luftdruckänderungsrate zugrunde gelegt. Wenn Du die 10 Minuten für eine Kalibrierphase auf die aktuelle Luftdruckänderungsrate nicht hast und sofort losmessen möchtest, mußt Du Dich eben beeilen und die Messtrecke möglichst in 15 Minuten zurücklegen, so dass der Fehler durch Luftdruckänderungen klein ist.

Deine Messkurve scheint soweit in Ordnung, Du hast "Höhenmeter" aufgetragen, oder?
Allerdings scheint die Kurve ein bisschen zu "zappelig" zu sein, d.h. Du bekommst von Messung zu Messung Schwankungen von einem Höhenmeter. Dies könntest Du vermeiden durch:
- Verwendung der höchsten Sensorauflösung beim Messen
- Maximales eingebautes "Oversampling" des Sensors verwenden
- Die Werte selbst durch zig bis tausendfache Messung nacheinander mitteln oder glätten

Wegen der Einbeziehung der Temperatur vom BMP085 in Deine Höhenformel allerdings mal eine Rückfrage:
Hast Du das Messgerät draussen unter freiem Himmel liegen gehabt, so dass Du als Temperatur die Außentemperatur eingerechnet hast? Ich würde eher empfehlen, die Temperatur NICHT in die Höhenformel einzurechnen, und nur die Luftdruckänderungen zu berücksichtigen, mit folgender Berechnung:
    float pressure=aktuellGemessenerLuftdruck; // in hPa, durch Mittelwertbildung geglättet vom BMP085
    float altitude=(1 - pow(pressure / 1013.25,1/5.255))*288.15/0.0065;
1290  International / Deutsch / Re: Auswahltaster für Programmabschnitt on: October 22, 2013, 03:02:17 pm
Hab den eigentlichen Programmcode zum testen nur in einen Loop geschrieben (in den andern loops was anderes) und da hat es funktioniert, wenn ich ihn auch in die anderen schreibe funktioniert es nicht.

Vermeide "es", das nicht funktioniert (was immer das auch sein mag) und Du bist auf gutem Wege!
Pages: 1 ... 84 85 [86] 87 88 ... 194