Dann ist der String auch leer.
@combie: Wo Du recht hast...
Aber meine Anschlußfrage wäre dann: Wo kommt die ominöse 6 her? Ein String-Objekt sollte - selbst wenn es eine leere Zeichenkette enthält - etliche Bytes mehr haben wenn ich mir die Klassendefinition so anschaue.
Falsch!
6 passt schon.
Ok, muß mal sehn, auf was die 6 reagiert...
was war Basic so einfach 
C oder C++ Handbuch und schauen was sizeof so tut, könnte helfen.
Hmm - nochmal genau nachschau... Ja.
Danke!
Dann könnte man sich noch die Implementation der String Klasse ansehen, was denn genau die 6 Bytes eines String Objekts sind. (Ein Tip: Hat nichts mit der Länge des zugehörigen Textes zu tun.)
Klar!
protected:
char *buffer; // the actual char array
unsigned int capacity; // the array length minus one (for the '\0')
unsigned int len; // the String length (not counting the '\0')
Da sind die 6 Byte der Instanz.
Weitere 4 Byte sind Klassenvariablen.
Zählen also zu den globalen Variablen.
Danke,
d.h. auch hier ist der String leer.
mein Prob reduziert sich also auf die Aufgabe, die Var-Typen so zu wechseln vom
unsigned Int (millis) zu einem String oder char_array, da ich dem Vdrive vorher mitteilen muß, wieviele Zeichen ich übertrage. Also muß ich entweder die Länge wissen oder ich schicke sie einzeln, dann muß das charAt funktionieren.
Nein. Sizeof hat nichts mit der Textlänge eines Strings zu tun. Dafür gibt es die Methode length().
Und Strings wurden nur erfunden, weil "die Arduino Sprache" wie Java aussehen sollte. Besser funktionieren tut alles ohne String Objekte.
Eigentlich werden Zeichen immer einzeln gesendet. Was du meinst, ist zu jedem Zeichen noch mehr Zusatzinformation zu senden ?
Na ja, length() hat ja auch 0 als Länge gebracht, also ist der String wohl leer, wie combie schon schrieb. Weiteres Indiz: charAt findet auch nix. Siehe #1.
Bahnhof!
Was ist dein Vdrive?
Und nein ohne String kein charAt!
Also, bei dem µC Zwerg wundert mich nicht, dass dem der Heap ausgeht und irgendwann nur noch nullptr liefert.
Habe dein Programm mal etwas verschlankt!
#include <Streaming.h> // die Lib findest du selber ;-)
Print &cout = Serial; // cout Emulation für "Arme"
int alt1 = 0;
int neu1 = 0;
unsigned long start1 = millis();
unsigned long stop1 = 0;
unsigned long dif1 = 500;
unsigned long Zahl1 = 0;
int alt2 = 0;
int neu2 = 0;
unsigned long start2 = millis();
unsigned long stop2 = 0;
unsigned long dif2 = 500;
unsigned long Zahl2 = 0;
String str = "";
//==============================
void setup()
{
pinMode(3, INPUT_PULLUP);
pinMode(4, INPUT_PULLUP);
Serial.begin(9600);
}
//=================================
void loop()
{
neu1 = digitalRead(3);
neu2 = digitalRead(4);
//===========================
if (neu1 < alt1) // FALLING
{
stop1 = millis();
dif1 = stop1 - start1 ;
start1 = millis();
//str = String(millis()) + F(" - ") + String(dif1) + " - " + String(dif2);
cout << millis() << F(" - ") << dif1 << F(" - ") << dif2 << endl;
}
else if ((millis() - start1) > 1800500)
{
dif1 = 1800500;
start1 = millis();
}
alt1 = neu1;
//===============================
if (neu2 < alt2) // FALLING
{
stop2 = millis();
dif2 = stop2 - start2 ;
start2 = millis();
cout << millis() << F(" - ") << dif1 << F(" - ") << dif2 << endl;
}
else if ((millis() - start2) > 1800500)
{
dif2 = 1800500;
start2 = millis();
}
alt2 = neu2;
}
Grüß dich,
Vdrive2 ist ein kleines Gerät, dem man mit SPI oder UART Daten übergibt, mit dem Auftrag, die in eine Datei auf einem USB-Stick zu schreiben. Will damit Solar und Eigenverbrauch mitschreiben und später auswerten.
Inzwischen hab ich den Fehler stark umzingelt,
genau das tuts nicht. Tatsächlich bleibt der String leer, obwohl strung als String deklariert ist:
strung = String(millis());
Serial.println(strung);
Das Zingeln hättest du einfacher haben können....
In der Libc Doku steht ganz klar:
void* malloc ( size_t __size )
The malloc() function allocates
sizebytes of memory. If malloc() fails, a NULL pointer is returned.
Nachtrag:
Diese kleine Funktion sagt dir den größten verfügbaren Block auf dem Heap
unsigned biggestBlock()
{
void *ptr;
unsigned n = 0;
while((ptr = malloc(n+1)))
{
free(ptr);
n += 1;
}
return n;
}
Somit könntest du VORHER schon prüfen, ob String den Platz reservieren kann
Ohne String, per
Serial.println(millis());
wird es wohl gehen ...
size_t len = Serial.print(millis()); // liefert dir auch die Anzahl Ziffern
Grundregel: Wenn String Probleme macht, ist der Verzicht auf String immer die einfachste Lösung.
Das sagt aber nichts darüber aus, warum du angeblich charAt benötigst.
Oder warum dir Print nicht reicht.
Das kann ich dir nicht glauben. Wie kommst du darauf?
Vor dem Übertragen der Daten muß ich melden, wieviele ich senden will.
Das "MRF xxxx" teilt das mit. Wenn ich das nicht weiß, melde ich immer nur eins an.
Daher muß ich dann jeden Text zeichenweise einzeln übertragen. Hab ich mit einem PIC schon erfolgreich gemacht.
zu2:
Zwischen SPI und RS232 sind die Pegel +/- vertauscht und die Level 0 > 5V/12V > -12V verschieden. Allerdings erkennt RS232 < 0.7 V als -12 und > 2.5 V als +12.
Also muß man nur invertieren und schon klappts.
Hast du den Verdacht, daß es Speicherprobleme gibt?
Der Compiler sagt, daß nur 50% des Platzes für die Variablen verbraucht sind.
@Michael_x:
"Wenn String Probleme macht, ist der Verzicht auf String immer die einfachste Lösung."
Das ist Feigheit vor dem Feind 
Auch das trägt nicht zu meinem Verständnis bei.
Ein gewisses Grundverständnis über die typischen Schnittstellen kannst du bei mir eigentlich schon voraussetzen.
Du verwendest Serial, ganz offensichtlich. Was anderes habe ich bei dir hier noch nicht gesehen. Und die Tiny Serial Implementierung ist halt Softserial, also nix SPI. Zudem hat der Tiny keine SPI Einheit, sondern nur eine USI
Ich würde mal sagen, den Beweis hast du im ersten Beitrag schon geliefert.
Trivial formuliert:
50% von wenig, ist noch weniger.
Und dann ist noch Platz für den Stack übrig zu behalten.
Und jetzt wirds lustig, auch ein Sketch mit nur diesen 3 Zeilen bringt nur Stringlänge 0. Da stimmt doch was mit meinem System nicht,oder?
String strung = String(millis());
//======================
void setup() {
Serial.begin(9600);
Serial.println(strung.length());
}
//======================
void loop() {
}
und das ohne Warnung oder Fehlermeldung