ATtiny85 Speicher knapp, was tun?

HaWe · 12.12.2017, 21:24

Zitat von spunky9003

so, noch mal...

ich habe hier zwei Code Schnipsel:

wird der erste Code compiliert, brauche ich 5.900 byte (Program size: 5.900 bytes (used 98% of a 6.012 byte maximum) (0,62 secs)):

Code:

		.
		.
		.
//		wenn eingang <> "!" und fehler = 1, dann ausgang = (eingang(!*) + 1) & "!" & (eingang(!*) + 1)
		else if (inString.indexOf("!") == 0 && analogRead(1) > 1000) {
			mySerial.println(inp + "!" + out);
		}
//		wenn eingang <> "!" und fehler = 0, dann ausgang = (eingang(!*) + 1)
//		else if (inString.indexOf("!") == 0 && analogRead(1) < 1000) {
//			mySerial.println(out);
//		}

wird der zweite Code compiliert, brauche ich 6.400 byte (Program too big. The size is 6400 bytes (of a 6012 byte maximum).):

Code:

		.
		.
		.
//		wenn eingang <> "!" und fehler = 1, dann ausgang = (eingang(!*) + 1) & "!" & (eingang(!*) + 1)
//		else if (inString.indexOf("!") == 0 && analogRead(1) > 1000) {
//			mySerial.println(inp + "!" + out);
//		}
//		wenn eingang <> "!" und fehler = 0, dann ausgang = (eingang(!*) + 1)
		else if (inString.indexOf("!") == 0 && analogRead(1) < 1000) {
			mySerial.println(out);
		}

Im 2. Abschnitt wird weniger Code benutzt, doch ich brauch 500 byte mehr! Kann mir das mal jemand erklären? Ich benutze Visual Micro (Arduino), bei Atmel Studio 7 blick ich leider nicht durch und habe es wieder deinstalliert.

hallo,
wo ist da der Unterschied zwischen den beiden Codes?
500 bytes Unterschied bei sonst gleichem Code klingt nach Verwendung anderer Libs - aber was genau wurde denn jetzt anders gemacht?
Evtl. brauchen wir sonst hier sicher den kompletten, ungekürzten Code.

**spunky9003** · 12.12.2017, 21:43

es ist jeweils der gleiche Code, nur wurde nur einmal der obere, dann der untere Teil auskommentiert und compiliert, alles andere ist 100% identisch.

habe den Code nochmal farblich hervorgehoben. https://www.roboternetz.de/community...l=1#post641058

HaWe · 12.12.2017, 22:09

ah, alles klar, hier wird in der Serial-Class erst die auszugebende Zeichenkette quasi per String-class-Methoden verlängert.
Versuche mal, den Ausgabe-string mit normalen ANSI-strcat-Methoden außerhalb von Serial zusammenzusetzen und dann erst in der kompletten neuen Variante per Serial auszugeben!

Testweise:
was macht das hier:

mySerial.print(inp);
mySerial.print("!");
mySerial.println(out);

Falls möglich, verwende auch keine String Class, sondern ANSI-C-strings, also char[] bzw. char *, das spart mächtig Speicher.

**spunky9003** · 16.12.2017, 17:51

ich habe den Code nochmal überarbeitet, ich konnte ihn noch ein wenig optimieren. Leider noch immer ca. 100 Byte zu viel für den ATtiny85. Ich bin leider nicht so der Profi, sieht jemand eine Möglichkeit den Code noch weiter zu optimieren, bei den wenigen Zeilen wahrscheinlich nicht so einfach.

Code:

/*
Name:		Sketch1.ino (speziell für IR Reflexlichtschranke, TCRT 5000)
Created:	06.12.2017 14:10:36
*/

#include <SoftSerial.h>

SoftSerial mySerial(4, 0);     // RX, TX
const int LED_out = 1;         // onboard LED auf Model A
//const int DIST_in = 2;         // Sharp Distance Sensor
const int IR_in = 2;           // IR Modul, Empfänger
const int IR_out = 3;          // IR Modul, Sender
long lasttime;
//String err = "";
String out_l = "";
String out_r = "1";
//String outString = "1";
String inString = "";

void setup() {
	mySerial.begin(9600);
	//pinMode(DIST_in, INPUT); // Sharp Distance Sensor
	pinMode(LED_out, OUTPUT); // LED Fehlermeldung
	pinMode(IR_out, OUTPUT); // IR Modul, Sender
	pinMode(IR_in, INPUT); // IR Modul, Empfänger
}

void loop() {

	if (millis() - lasttime > 500) {

		digitalWrite(IR_out, HIGH); // IR Modul, Sender ein
		digitalWrite(LED_out, LOW); // LED Fehlermeldung aus

		while (mySerial.available() > 0) { // sind Daten vorhanden, dann
			inString += (char)mySerial.read(); // Daten von anderen Modul einlesen
		}

		if (inString != "") { // wurden Daten eingelesen, dann
			out_r = inString.substring(inString.indexOf("!") + 1, inString.indexOf("\n") - 1).toInt() + 1; // eigene Modul-Nummer berechnen
		}


		if (analogRead(1) < 300 || analogRead(1) > 900) { // IR Modul, Empfänger abfragen, dann
			digitalWrite(LED_out, HIGH); // LED Fehlermeldung ein
			out_l = out_r; // eigene Modul-Nummer für Fehlermeldung merken
		}
		else { // keine Fehlermeldung
			out_l = "";
		}

		if (inString.indexOf("!") > 0 && out_l == "") { // Fehlermeldung von anderen Modul und keine Fehlermeldung vom eigenen Modul, dann
			out_l = inString.substring(0, inString.indexOf("!")); // Fehlermeldung von anderen Modul weiterleiten
		}
		else if (inString.indexOf("!") > 0 && out_l != "") { // Fehlermeldung von anderen Modul und Fehlermeldung vom eigenen Modul, dann
			out_l = inString.substring(0, inString.indexOf("!")) + "," + out_r; // Fehlermeldung von anderen Modul und Fehlermeldung vom eigenen Modul weiterleiten
		}


		mySerial.println(out_l + "!" + out_r); // Daten zum nächsten Modul schicken, Fehlermeldung(en) + "!" + eigene Modul-Nummer

		inString = ""; // Eingangsdaten löschen

		digitalWrite(IR_out, LOW); // IR Modul, Sender aus

		lasttime = millis();
	}

}

HaWe · 16.12.2017, 19:58

Zitat von spunky9003

ich habe den Code nochmal überarbeitet, ich konnte ihn noch ein wenig optimieren. Leider noch immer ca. 100 Byte zu viel für den ATtiny85. Ich bin leider nicht so der Profi, sieht jemand eine Möglichkeit den Code noch weiter zu optimieren, bei den wenigen Zeilen wahrscheinlich nicht so einfach.

Code:

/*
Name:		Sketch1.ino (speziell für IR Reflexlichtschranke, TCRT 5000)
Created:	06.12.2017 14:10:36
*/

#include <SoftSerial.h>

SoftSerial mySerial(4, 0);     // RX, TX
const int LED_out = 1;         // onboard LED auf Model A
//const int DIST_in = 2;         // Sharp Distance Sensor
const int IR_in = 2;           // IR Modul, Empfänger
const int IR_out = 3;          // IR Modul, Sender
long lasttime;
//String err = "";
String out_l = "";
String out_r = "1";
//String outString = "1";
String inString = "";

void setup() {
	mySerial.begin(9600);
	//pinMode(DIST_in, INPUT); // Sharp Distance Sensor
	pinMode(LED_out, OUTPUT); // LED Fehlermeldung
	pinMode(IR_out, OUTPUT); // IR Modul, Sender
	pinMode(IR_in, INPUT); // IR Modul, Empfänger
}

void loop() {

	if (millis() - lasttime > 500) {

		digitalWrite(IR_out, HIGH); // IR Modul, Sender ein
		digitalWrite(LED_out, LOW); // LED Fehlermeldung aus

		while (mySerial.available() > 0) { // sind Daten vorhanden, dann
			inString += (char)mySerial.read(); // Daten von anderen Modul einlesen
		}

		if (inString != "") { // wurden Daten eingelesen, dann
			out_r = inString.substring(inString.indexOf("!") + 1, inString.indexOf("\n") - 1).toInt() + 1; // eigene Modul-Nummer berechnen
		}


		if (analogRead(1) < 300 || analogRead(1) > 900) { // IR Modul, Empfänger abfragen, dann
			digitalWrite(LED_out, HIGH); // LED Fehlermeldung ein
			out_l = out_r; // eigene Modul-Nummer für Fehlermeldung merken
		}
		else { // keine Fehlermeldung
			out_l = "";
		}

		if (inString.indexOf("!") > 0 && out_l == "") { // Fehlermeldung von anderen Modul und keine Fehlermeldung vom eigenen Modul, dann
			out_l = inString.substring(0, inString.indexOf("!")); // Fehlermeldung von anderen Modul weiterleiten
		}
		else if (inString.indexOf("!") > 0 && out_l != "") { // Fehlermeldung von anderen Modul und Fehlermeldung vom eigenen Modul, dann
			out_l = inString.substring(0, inString.indexOf("!")) + "," + out_r; // Fehlermeldung von anderen Modul und Fehlermeldung vom eigenen Modul weiterleiten
		}


		mySerial.println(out_l + "!" + out_r); // Daten zum nächsten Modul schicken, Fehlermeldung(en) + "!" + eigene Modul-Nummer

		inString = ""; // Eingangsdaten löschen

		digitalWrite(IR_out, LOW); // IR Modul, Sender aus

		lasttime = millis();
	}

}

mein Tipp ging in die Richtung, die String Klasse so weit wie möglich weg zu lassen.
Also:
statt String out_l = ""; // <<< das ist dei Arduinoo String Class String. Braucht viel Speicher mit seinen ganzen String Class Methoden im Programmspeicher
also jetzt stattdessen:
char out_l[50]=""; // <<< das ist ein C string, also ein char array mit deutlich weniger Memory-Bedarf im Programmspeicher.

ich habe hier willkürlich 50 char Länge gewählt, du musst es ntl auf deinen Bedarf hin optimieren.
Entsprechend sind dann auch die anderen Arduino Strings durch C strings zu ersetzen.

C strings kann man nicht addieren, dazu werden hingegen die folgenden weniger Speicher-hungrigen C Funktionen verwendet:
strcpy()
strncpy()
strcat()
strncat()
memcpy()

char out_l[50]="";
geht auch nur beim 1. Initialisieren, danach muss es heißen
strcpy(out_l[50], "");

Achte darauf, dass deine C strings immer mit einer Null terminiert sind (Zahl Null = '\0', nicht Zeichen '0'). Manche C-Funktionen ergänzen den automatisch, manche nicht.
http://www.cplusplus.com/reference/cstring/strcat/
http://www.cplusplus.com/reference/cstring/strcpy/

**Ceos** · 16.12.2017, 20:15

je nachdem wie gut der compiler schjon optimiert könntest du aus deinen kontanten ROM konstanten machen und so ein paar byte init code sparen (geht aber minimal zu lasten der geschwindigkeit)

const int -> const PROGMEM short .... je nachdem wie dein compiler arbeitet kann dein int 16 oder 32bit groß sein udn short ist nur 8bit

WARNUNG: wenn er PROGMEM nicht compilieren kann liegt es daran dass es eine instruktion ist die nur ein AVR compiler kann

**spunky9003** · 17.12.2017, 11:29

ok, ich probiere das mal...

...hab dann noch überlegt, alle Daten bit-weise zu übertragen, es sollen ja mehrere Module seriell verbunden werden, könnte dann bei 8 Modulen so aussehen, das erste Byte gibt eine Fehlermeldung weiter, das zweite Byte gibt die aktuelle Modul-Nummer ans nächste Modul:

Modul 1 sendet: 00000000 00000001 (Modul 1 ok)
Modul 2 sendet: 00000000 00000010 (Modul 1+2 ok)
Modul 3 sendet: 00100000 00000011 (Modul 1+2 ok, Modul 3 Fehler)
Modul 4 sendet: 00100000 00000100 (Modul 1+2+4 ok, Modul 3 Fehler)
Modul 5 sendet: 00100000 00000101 (Modul 1+2+4+5 ok, Modul 3 Fehler)
Modul 6 sendet: 00100000 00000110 (Modul 1+2+4+5+6 ok, Modul 3 Fehler)
Modul 7 sendet: 00100010 00000111 (Modul 1+2+4+5+6 ok, Modul 3+7 Fehler)
Modul 8 sendet: 00100010 00001000 (Modul 1+2+4+5+6+8 ok, Modul 3+7 Fehler)

Auf dem Modul brauch keine Auswertung erfolgen, es muss nur die empfange Modul-Nummer um 1 erhöht werden und bei einem Fehler muss ein bit an der richtigen Stelle auf 1 gesetzt werden.

---

Edit: mit der binären Übertragung brauche ich nur 3 kByte Programmspeicher, da spare ich mir das ganze String-Geraffel, warum nicht gleich so...

**Ceos** · 18.12.2017, 17:31

netter ansatz

HaWe · 18.12.2017, 23:14

Zitat von spunky9003

ok, ich probiere das mal...

...hab dann noch überlegt, alle Daten bit-weise zu übertragen, es sollen ja mehrere Module seriell verbunden werden, könnte dann bei 8 Modulen so aussehen, das erste Byte gibt eine Fehlermeldung weiter, das zweite Byte gibt die aktuelle Modul-Nummer ans nächste Modul:

Modul 1 sendet: 00000000 00000001 (Modul 1 ok)
Modul 2 sendet: 00000000 00000010 (Modul 1+2 ok)
Modul 3 sendet: 00100000 00000011 (Modul 1+2 ok, Modul 3 Fehler)
Modul 4 sendet: 00100000 00000100 (Modul 1+2+4 ok, Modul 3 Fehler)
Modul 5 sendet: 00100000 00000101 (Modul 1+2+4+5 ok, Modul 3 Fehler)
Modul 6 sendet: 00100000 00000110 (Modul 1+2+4+5+6 ok, Modul 3 Fehler)
Modul 7 sendet: 00100010 00000111 (Modul 1+2+4+5+6 ok, Modul 3+7 Fehler)
Modul 8 sendet: 00100010 00001000 (Modul 1+2+4+5+6+8 ok, Modul 3+7 Fehler)

Auf dem Modul brauch keine Auswertung erfolgen, es muss nur die empfange Modul-Nummer um 1 erhöht werden und bei einem Fehler muss ein bit an der richtigen Stelle auf 1 gesetzt werden.

---

Edit: mit der binären Übertragung brauche ich nur 3 kByte Programmspeicher, da spare ich mir das ganze String-Geraffel, warum nicht gleich so...

schön zu sehen, dass der Verzicht auf die String Klasse, wie ich vermutet habe, tatsächlich so viel Speicher-Ersparnis bringt.
Jetzt spiel doch mal ein bisschen mit den ANSI C strings rum, und sei es nur, um klassisches C zu lernen: ich bin sicher, dass der Speicherbedarf selbst dann nicht wieder ins Monströse anwachsen wird.

**Ceos** · 19.12.2017, 16:02

dass der Verzicht auf die String Klasse, wie ich vermutet habe, tatsächlich so viel Speicher-Ersparnis bringt

Dinge wie strings, modulo rechnung oder floating point berechungen kosten MASSIV speicher, da immer gleich die ganze bibliothek eingebunden wird, ohne das auszukommen ist aber definitiv nicht einfach

ich hätte es zwar auch gerne empfohlen aber da mir eine hinreichende alternative fehlte hab ich mich da lieber rausgehalten