Den Compiler zählen lassen

Forum 2005-2010 (read only) International Deutsch
1

Ich habe in meinem Boostcontroller diesen Switch case drinnen kann mir einer sagen wie ich den Code compacter hinbekomme und der Compiler für mich zählt mit ich blicke da im Moment garnicht durch da ich nicht aus dem C# bereich komme
```

  • switch (rpmact) {
       default:
         PWMval=0;
         break;
       case 20:
         PWMval=rpm20;
         break;  
       case 21:
         PWMval=rpm21;
         break;
       case 22:
         PWMval=rpm22;
         break;    
       case 23:
         PWMval=rpm23;
         break;
       case 24:
         PWMval=rpm24;
         break;
       case 25:
         PWMval=rpm25;
         break;
       case 26:
         PWMval=rpm26;
         break;
       case 27:
         PWMval=rpm27;
         break;
       case 28:
         PWMval=rpm28;
         break;
       case 29:
         PWMval=rpm29;
         break;
       case 30:
         PWMval=rpm30;
         break;
       case 31:
         PWMval=rpm31;
         break;
       case 32:
         PWMval=rpm32;
         break;    
       case 33:
         PWMval=rpm33;
         break;
       case 34:
         PWMval=rpm34;
         break;
       case 35:
         PWMval=rpm35;
         break;
       case 36:
         PWMval=rpm36;
         break;
       case 37:
         PWMval=rpm37;
         break;
       case 38:
         PWMval=rpm38;
         break;
       case 39:
         PWMval=rpm39;
         break;
       case 40:
         PWMval=rpm40;
         break;
       case 41:
         PWMval=rpm41;
         break;
       case 42:
         PWMval=rpm42;
         break;    
       case 43:
         PWMval=rpm43;
         break;
       case 44:
         PWMval=rpm44;
         break;
       case 45:
         PWMval=rpm45;
         break;
       case 46:
         PWMval=rpm46;
         break;
       case 47:
         PWMval=rpm47;
         break;
       case 48:
         PWMval=rpm48;
         break;
       case 49:
         PWMval=rpm49;
         break;
       case 50:
         PWMval=rpm50;
         break;
       case 51:
         PWMval=rpm51;
         break;
       case 52:
         PWMval=rpm52;
         break;    
       case 53:
         PWMval=rpm53;
         break;
       case 54:
         PWMval=rpm54;
         break;
       case 55:
         PWMval=rpm55;
         break;
       case 56:
         PWMval=rpm56;
         break;
       case 57:
         PWMval=rpm57;
         break;
       case 58:
         PWMval=rpm58;
         break;
       case 59:
         PWMval=rpm59;
         break;
       case 60:
         PWMval=rpm60;
         break;
       case 61:
         PWMval=rpm61;
         break;
       case 62:
         PWMval=rpm62;
         break;    
       case 63:
         PWMval=rpm63;
         break;
       case 64:
         PWMval=rpm64;
         break;
       case 65:
         PWMval=rpm65;
         break;
       }*
    * *Es ist nur ein Auszug Das Gleiche habe ich nochma beim Definieren der Constanten* *
    const int rpm20=100;        
    const int rpm21=110;        // rpm21=2100 an so on ......
    const int rpm22=120;
    const int rpm23=130;
    const int rpm24=140;
    const int rpm25=150;
    const int rpm26=160;
    const int rpm27=170;
    const int rpm28=180;
    const int rpm29=190;
    //3000-3900RPM
    const int rpm30=200;
    const int rpm31=210;
    const int rpm32=220;
    const int rpm33=230;
    const int rpm34=240;
    const int rpm35=250;
    const int rpm36=10;
    const int rpm37=20;
    const int rpm38=30;
    const int rpm39=40;
    //4000-4900RPM
    const int rpm40=50;
    const int rpm41=60;
    const int rpm42=70;
    const int rpm43=80;
    const int rpm44=90;
    const int rpm45=100;
    const int rpm46=110;
    const int rpm47=120;
    const int rpm48=130;
    const int rpm49=140;
    //5000-5900RPM
    const int rpm50=150;
    const int rpm51=160;
    const int rpm52=170;
    const int rpm53=180;
    const int rpm54=190;
    const int rpm55=200;      
    const int rpm56=210;
    const int rpm57=220;
    const int rpm58=230;
    const int rpm59=190;      
    //6000-65000RPM
    const int rpm60=200;
    const int rpm61=210;
    const int rpm62=220;
    const int rpm63=230;
    const int rpm64=240;      //.......
    const int rpm65=250;
    ```
    Für ein paar Tips wäre ich dankbar
2

Wenn Du die Konstanten so brauchst, dann vielleicht so

const unsigned int rpm = {100,110,120,130,140,150,160,170,180,190,200,210,220,230,240,250,10,20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210,220,230,190,200,210,220,230,240,250};

PWMval=0;
if (rpmact>=20 && rpmact<=65)
      PWMval=rpm[rpmact-20];

Ggf. kann man die Konstanten auch durch eine kleine Formel ersetzen, wenn Du sie nicht brauchst.

3

Die Konstanten werden hinterlegt und dem Charakter des Motors angepasst also wird man da wohle keine Formel machen.
Frage:
Werden die Konstanten in verschiedenen rpm hinterlegt?

Die ich dann an unterschiedlichen derhzahlpunkten abrufen kann?

Funktion ist nämlich so ich habe alle 100 u/min einen PWM Wert mit dem ich einen Solenoiden ansteuere und der ist abhänig von dem Motor bzw Turbolader und wird dann nur durch andere einfußwerte noch etwas erhöht bzw abgesenkt.
Ich will das Programm nur kompakter machen da es mitlerweile 9860bytes groß ist.

4

Frage:
Werden die Konstanten in verschiedenen rpm hinterlegt?

Ich bin jetzt nicht ganz sicher, was Du meinst...?

5

Du hat ja in den curley brackets die Werte wie kann ich jetzt den 5 Wert auslesen oder dann einfach mal den 12?
Das meinte ich hinter unsigned int rpm sind ja mehrer Werte hinterlegt

6

sollte wohl sowa wie

const unsigned int rpm[] = {100,110,120,130,140,150,160,170,180,190,200,210,220,230,240,250,10,20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210,220,230,190,200,210,220,230,240,250};

heißen.
rpm[] ist also ein Array, mit rpm[0] greifst du dann auf den ersten Wert zu (also 100), mit rpm[1] auf den zweiten (110), mit rpm[x] auf den "x minus 1"ten wert, usw.
Würde aber bei den Variablen sowieso nur den Code lesbarer machen, am Speicherplatz rüttelt das nicht, da eine unsigned int ob im Array oder für sich alleine immer 2 Byte belegt.
Bei der switch(case)-Konstruktion kann es schon sein, dass du Speicherplatz sparst, weiß nicht wass der Compiler da alles treibt...

Edit: hab gerade gesehen, dass du in deinem Sketch sowieso immer nur ints für die rpm-Variablen benutzt hast, obwohl keine einen größeren Wert als 250 hat. Die kannst du alle statt als Integer-Zahlen als Bytes anlegen, da sparste schon mal soviele Bytes wie du Variablen hast (vorausgesetzt alle rpm-Variablen sind kleiner als 256 und werden auch im Verlauf des Sketches nicht größer...)

Edit2: By the way, wenn die Variablen sich sowieso nie ändern und du sie eh fix im Sketch vorgibst, kannst du auch #define benutzen, dann brauchste für die "Variablen" (die ja wenig variabel sind) gar keinen Programmspeicher zu verschleudern, das macht dann alles der Compiler für dich (nochmal zum nachlesen: #define - Arduino Reference)

7

Danke schon mal auf die Define beschreibung bin ich noch garnicht gekommen. Ich will die "Variabeln" auch nicht ändern die sind fest hinterlegt sie bekommen nur einen Korrekturwert abhänig von gewissen gegebenheiten. Aber mit dem Speicher wird wohl relativ da ich mittlerweile gewzungen bin auf den Mega von Seeed umzusteigen da mit die DI/DO bzw AI ausgehen und ich auch noch ein lcd nokia shiel betreibe.

8

Entschuldigt, wenn ich mich da einmische, aber Define gibt einer Sache nur einen anderen Namen, z.B. zwecks Übersichtlichkeit.
Der Compiler wird alle Stellen, an denen ein Define-Labels auftauchen, beim compilieren durch die entsprechenden Werte ersetzen, und Du hast nichts gewonnen.

Was Du aber machen könntest (prinzipiell, auch wenn Dus jetzt nicht mehr brauchst) wäre das PROGMEM-Keyword zu benutzen. Damit kannst Du konstante Werte im Flash hinterlegen statt im RAM, und davon haben wir ja ungleich mehr zur Verfügung. :slight_smile:

9

Praktisch hab ichs noch nicht probiert, aber theoretisch lese ich hier gerade, dass durch das const die Variablen/das Array eh im Flash bleibt und nicht ins RAM kopiert wird, und somit auch keinen "Speicher verbraucht". :slight_smile:

Kann das jemand mit Erfahrung bestätigen?

10

Das mit dem Progmem hört sich ja mal richtig interessant an kann ich mit Progmem auch etwas nicht flüchtig im Flash speichern und dann beim nächsten start bzw boot mir ne Variable einlesen.

Für mein Projekt z.b. eine Variable anpassen z.b ein korrekturwert für eine Bestimmte Variable (Offset oder ähnlich) die ich dann speichern kann und wieder beim nächsten boot auslesen zwischendurch speichern und dann dann beim erneuten einschalten wieder auslesen

11

Nein, das Flash wird vom Computer beschrieben, das kann der Arduino nicht.

Aber für das, was Du vor hast gibts nen separaten Speichertypen, guckt Dir mal das EEPROM an.

12

das Problem mit eeprom das dieser nur eine beschränkte Lebensdauer hat wenn man den zu oft beschreibt das heisst die Lebenzeit verkürzt sich

13

Richtig, aber immerhin sind 100.000 Schreibzyklen pro Zelle zugesichert, und das ist dann bei den meisten Zellen noch lange nicht das Ende der Fahnenstange; und für Konfigurationsdaten, die nur bei speziellen Anpassungen geschrieben werden, sollte das üppig reichen. :wink:

Und man kann ja die Zellen beim Schreiben z.B. durch ein Rundlauf-Verfahren abwechseln, damit könnte man auf ein Vielfaches der minimalen Lebensdauer kommen, wenns denn sein müsste... :slight_smile:

14

Eins ist mir noch eingefallen: Wenn Du wirklich damit rechnest, mehr als 100.000 Schreibzyklen pro Byte zu brauchen, und dabei aber weniger als 56 Bytes insgesamt benötigst, dann könntest Du Dir z.B. mit einer Echtzeituhr behelfen. :wink:

Der da verwendete Chip hat laut Datenblatt 56 Bytes zur freien Verfügung an RAM übrig, die man problemlos für eigene Zwecke verwenden kann, und die Batterie sorgt dafür, dass dieses RAM mindestens 9 Jahre (typischerweise 17) nichtflüchtig bleibt. :slight_smile:

15

Ich brauche den Speicher weil das ein sich selbst optimierter Regler wird. Also der Arduino regelt den Ladedruck anahand einer hinterlegten Kurve. Tanke ich jetzt E85 habe ich andere verhälnisse bezüglich Lambda und einspritzzeiten(länge) (dann kann ich dann Druck erhöhen => soll der regler selber machen) dann soll der Regler den korrektur(Offset)Wert speichern und beim nächsten Start auslesen und dann wieder das Spiel

16

Alles klar.

Wenn Dir die 56 Bytes nicht reichen könntest Du mal nach "FRAM" gucken, das ist quasi wie EEPROM, aber schneller im Beschreiben und verträgt 10^10 Schreib-/Lesezyklen, Beispiel. :slight_smile:

Leider finde ich für diese RAMs kein anschlussfertiges Modul, kennt da jemand was? :frowning:

17

Das ist ja eine gute Lösung ist aber dann über I²C zu steuern aber bstimmt machbar

18

I²C ist kein Problem, gibts ne Library für. :slight_smile:

Wenn Dus tatsächlich so machst wärs klasse, wenn Du Deine Beschaltung anschließend hier reinhängen würdest... :wink:

19

Das versteht sich von selber. Man muss den Code wahrscheinlich dann ein bisschen aufteilen da er im Moment wie geschrieben ca 9k hat. Mit dem FeRAM brauche ich noch ne gute quelle will nicht den chip einzeln irgendwo kaufen beim großen C oder bei Reichelt wäre das schon gut.

20

Ich habe mal ne Sample anforderung an RAMTROn geschickt mal sehen was passiert ob nur ignoriert wird oder was bei rumkommt