microcontroller

>Was kan ich machen so dass meine code sneller lauft?

Evtl. kann auch eine Optimierung des Programmes helfen oder etwas
Peripherie, die den µC unterstützt.

>Kan jemant mich erzellen welkche processor langzaam ist bisder
snelste?

Das ist kaum möglich, da die Anzahl der Controller zu gross ist.
Schneller als die C-Control ist allerdings keine Kunst...

Etwas mehr Information über Dein Projekt wäre hilfreich, so kann man
Dir vielleicht einen optimalen µC empfehlen.

Gruß
Thomas

Nun die aufgade is viele werte aufzehlen und dan durch ein filter durch
lassen.
Die code kan nicht mir optimalisiert wurden.
(ist code der fruher in 64k musiek und grafiek benust ist.)
Ich programmiere in c-controll ide, das ist doch c++?

When ich nach ein andere uP umshalte, will ich auch eine seite auf
internet uber den 'snellere' uP vinden, wie die
'http://www.cc2net.de/cc2net.html'; site.

die code volgt unter.
Ich weis dat float nicht snell ist, aber der filter must es haben.
Ich habe auch keine for loop genutst, so das het vielleich sneller
geht.

ps. Diese code wirt nach succes, grosser, darum hab ich ein snellere uP
notig.

float Y[100],Yn[100],Ya[100],Temp;

int T,P;

thread main
{
//  lcdext.init();
//  lcdext.clear();



Y[5]=200;

 loop
 {
Yn[0]=(Y[1]-Y[0])+(Y[10]-Y[0])+(0-Y[0])+(0-Y[0]);

Yn[1]=(Y[0]-Y[1])+(Y[11]-Y[1])+(Y[2]-Y[1])+(0-Y[1]);
Yn[2]=(Y[1]-Y[2])+(Y[12]-Y[2])+(Y[3]-Y[2])+(0-Y[2]);
Yn[3]=(Y[2]-Y[3])+(Y[13]-Y[3])+(Y[4]-Y[3])+(0-Y[3]);
Yn[4]=(Y[3]-Y[4])+(Y[14]-Y[4])+(Y[5]-Y[4])+(0-Y[4]);
Yn[5]=(Y[4]-Y[5])+(Y[15]-Y[5])+(Y[6]-Y[5])+(0-Y[5]);
Yn[6]=(Y[5]-Y[6])+(Y[16]-Y[6])+(Y[7]-Y[6])+(0-Y[6]);
Yn[7]=(Y[6]-Y[7])+(Y[17]-Y[7])+(Y[8]-Y[7])+(0-Y[7]);
Yn[8]=(Y[7]-Y[8])+(Y[18]-Y[8])+(Y[9]-Y[8])+(0-Y[8]);

Yn[9]=(Y[8]-Y[9])+(Y[19]-Y[9])+(0-Y[9])+(0-Y[9]);


Yn[10]=(Y[20]-Y[10])+(Y[11]-Y[10])+(Y[0]-Y[10])+(0-Y[10]);

Yn[11]=(Y[10]-Y[11])+(Y[21]-Y[11])+(Y[12]-Y[11])+(Y[1]-Y[11]);
Yn[12]=(Y[11]-Y[12])+(Y[22]-Y[12])+(Y[13]-Y[12])+(Y[2]-Y[12]);
Yn[13]=(Y[12]-Y[13])+(Y[23]-Y[13])+(Y[14]-Y[13])+(Y[3]-Y[13]);
Yn[14]=(Y[13]-Y[14])+(Y[24]-Y[14])+(Y[15]-Y[14])+(Y[4]-Y[14]);
Yn[15]=(Y[14]-Y[15])+(Y[25]-Y[15])+(Y[16]-Y[15])+(Y[5]-Y[15]);
Yn[16]=(Y[15]-Y[16])+(Y[26]-Y[16])+(Y[17]-Y[16])+(Y[6]-Y[16]);
Yn[17]=(Y[16]-Y[17])+(Y[27]-Y[17])+(Y[18]-Y[17])+(Y[7]-Y[17]);
Yn[18]=(Y[17]-Y[18])+(Y[28]-Y[18])+(Y[19]-Y[18])+(Y[8]-Y[18]);

Yn[19]=(Y[18]-Y[19])+(Y[29]-Y[19])+(Y[9]-Y[19])+(0-Y[19]);


Yn[20]=(Y[30]-Y[20])+(Y[21]-Y[20])+(Y[10]-Y[20])+(0-Y[20]);

Yn[21]=(Y[20]-Y[21])+(Y[31]-Y[21])+(Y[22]-Y[21])+(Y[11]-Y[21]);
Yn[22]=(Y[21]-Y[22])+(Y[32]-Y[22])+(Y[23]-Y[22])+(Y[12]-Y[22]);
Yn[23]=(Y[22]-Y[23])+(Y[33]-Y[23])+(Y[24]-Y[23])+(Y[13]-Y[23]);
Yn[24]=(Y[23]-Y[24])+(Y[34]-Y[24])+(Y[25]-Y[24])+(Y[14]-Y[24]);
Yn[25]=(Y[24]-Y[25])+(Y[35]-Y[25])+(Y[26]-Y[25])+(Y[15]-Y[25]);
Yn[26]=(Y[25]-Y[26])+(Y[36]-Y[26])+(Y[27]-Y[26])+(Y[16]-Y[26]);
Yn[27]=(Y[26]-Y[27])+(Y[37]-Y[27])+(Y[28]-Y[27])+(Y[17]-Y[27]);
Yn[28]=(Y[27]-Y[28])+(Y[38]-Y[28])+(Y[29]-Y[28])+(Y[18]-Y[28]);

Yn[29]=(Y[28]-Y[29])+(Y[39]-Y[29])+(Y[19]-Y[29])+(0-Y[29]);


Yn[30]=(Y[40]-Y[30])+(Y[31]-Y[30])+(Y[20]-Y[30])+(0-Y[30]);

Yn[31]=(Y[30]-Y[31])+(Y[41]-Y[31])+(Y[32]-Y[31])+(Y[21]-Y[31]);
Yn[32]=(Y[31]-Y[32])+(Y[42]-Y[32])+(Y[33]-Y[32])+(Y[22]-Y[32]);
Yn[33]=(Y[32]-Y[33])+(Y[43]-Y[33])+(Y[34]-Y[33])+(Y[23]-Y[33]);
Yn[34]=(Y[33]-Y[34])+(Y[44]-Y[34])+(Y[35]-Y[34])+(Y[24]-Y[34]);
Yn[35]=(Y[34]-Y[35])+(Y[45]-Y[35])+(Y[36]-Y[35])+(Y[25]-Y[35]);
Yn[36]=(Y[35]-Y[36])+(Y[46]-Y[36])+(Y[37]-Y[36])+(Y[26]-Y[36]);
Yn[37]=(Y[36]-Y[37])+(Y[47]-Y[37])+(Y[38]-Y[37])+(Y[27]-Y[37]);
Yn[38]=(Y[37]-Y[38])+(Y[48]-Y[38])+(Y[39]-Y[38])+(Y[28]-Y[38]);

Yn[39]=(Y[38]-Y[39])+(Y[49]-Y[39])+(Y[29]-Y[39])+(0-Y[39]);


Yn[40]=(Y[50]-Y[40])+(Y[41]-Y[40])+(Y[30]-Y[40])+(0-Y[40]);

Yn[41]=(Y[40]-Y[41])+(Y[51]-Y[41])+(Y[42]-Y[41])+(Y[31]-Y[41]);
Yn[42]=(Y[41]-Y[42])+(Y[52]-Y[42])+(Y[43]-Y[42])+(Y[32]-Y[42]);
Yn[43]=(Y[42]-Y[43])+(Y[53]-Y[43])+(Y[44]-Y[43])+(Y[33]-Y[43]);
Yn[44]=(Y[43]-Y[44])+(Y[54]-Y[44])+(Y[45]-Y[44])+(Y[34]-Y[44]);
Yn[45]=(Y[44]-Y[45])+(Y[55]-Y[45])+(Y[46]-Y[45])+(Y[35]-Y[45]);
Yn[46]=(Y[45]-Y[46])+(Y[56]-Y[46])+(Y[47]-Y[46])+(Y[36]-Y[46]);
Yn[47]=(Y[46]-Y[47])+(Y[57]-Y[47])+(Y[48]-Y[47])+(Y[37]-Y[47]);
Yn[48]=(Y[47]-Y[48])+(Y[58]-Y[48])+(Y[49]-Y[48])+(Y[38]-Y[48]);

Yn[49]=(Y[48]-Y[49])+(Y[59]-Y[49])+(Y[39]-Y[49])+(0-Y[50]);


Yn[50]=(Y[60]-Y[50])+(Y[51]-Y[50])+(Y[40]-Y[50])+(0-Y[50]);

Yn[51]=(Y[50]-Y[51])+(Y[61]-Y[51])+(Y[52]-Y[51])+(Y[41]-Y[51]);
Yn[52]=(Y[51]-Y[52])+(Y[62]-Y[52])+(Y[53]-Y[52])+(Y[42]-Y[52]);
Yn[53]=(Y[52]-Y[53])+(Y[63]-Y[53])+(Y[54]-Y[53])+(Y[43]-Y[53]);
Yn[54]=(Y[53]-Y[54])+(Y[64]-Y[54])+(Y[55]-Y[54])+(Y[44]-Y[54]);
Yn[55]=(Y[54]-Y[55])+(Y[65]-Y[55])+(Y[56]-Y[55])+(Y[45]-Y[55]);
Yn[56]=(Y[55]-Y[56])+(Y[66]-Y[56])+(Y[57]-Y[56])+(Y[46]-Y[56]);
Yn[57]=(Y[56]-Y[57])+(Y[67]-Y[57])+(Y[58]-Y[57])+(Y[47]-Y[57]);
Yn[58]=(Y[57]-Y[58])+(Y[68]-Y[58])+(Y[59]-Y[58])+(Y[48]-Y[58]);

Yn[59]=(Y[58]-Y[59])+(Y[69]-Y[59])+(Y[49]-Y[59])+(0-Y[59]);


Yn[60]=(Y[70]-Y[60])+(Y[61]-Y[60])+(Y[50]-Y[60])+(0-Y[60]);

Yn[61]=(Y[60]-Y[61])+(Y[71]-Y[61])+(Y[62]-Y[61])+(Y[51]-Y[61]);
Yn[62]=(Y[61]-Y[62])+(Y[72]-Y[62])+(Y[63]-Y[62])+(Y[52]-Y[62]);
Yn[63]=(Y[62]-Y[63])+(Y[73]-Y[63])+(Y[64]-Y[63])+(Y[53]-Y[63]);
Yn[64]=(Y[63]-Y[64])+(Y[74]-Y[64])+(Y[65]-Y[64])+(Y[54]-Y[64]);
Yn[65]=(Y[64]-Y[65])+(Y[75]-Y[65])+(Y[66]-Y[65])+(Y[55]-Y[65]);
Yn[66]=(Y[65]-Y[66])+(Y[76]-Y[66])+(Y[67]-Y[66])+(Y[56]-Y[66]);
Yn[67]=(Y[66]-Y[67])+(Y[77]-Y[67])+(Y[68]-Y[67])+(Y[57]-Y[67]);
Yn[68]=(Y[67]-Y[68])+(Y[78]-Y[68])+(Y[69]-Y[68])+(Y[58]-Y[68]);

Yn[69]=(Y[68]-Y[69])+(Y[79]-Y[69])+(Y[59]-Y[69])+(0-Y[69]);


Yn[70]=(Y[80]-Y[70])+(Y[71]-Y[70])+(Y[60]-Y[70])+(0-Y[70]);

Yn[71]=(Y[70]-Y[71])+(Y[81]-Y[71])+(Y[72]-Y[71])+(Y[61]-Y[71]);
Yn[72]=(Y[71]-Y[72])+(Y[82]-Y[72])+(Y[73]-Y[72])+(Y[62]-Y[72]);
Yn[73]=(Y[72]-Y[73])+(Y[83]-Y[73])+(Y[74]-Y[73])+(Y[63]-Y[73]);
Yn[74]=(Y[73]-Y[74])+(Y[84]-Y[74])+(Y[75]-Y[74])+(Y[64]-Y[74]);
Yn[75]=(Y[74]-Y[75])+(Y[85]-Y[75])+(Y[76]-Y[75])+(Y[65]-Y[75]);
Yn[76]=(Y[75]-Y[76])+(Y[86]-Y[76])+(Y[77]-Y[76])+(Y[66]-Y[76]);
Yn[77]=(Y[76]-Y[77])+(Y[87]-Y[77])+(Y[78]-Y[77])+(Y[67]-Y[77]);
Yn[78]=(Y[77]-Y[78])+(Y[88]-Y[78])+(Y[79]-Y[78])+(Y[68]-Y[78]);

Yn[79]=(Y[78]-Y[79])+(Y[89]-Y[79])+(Y[69]-Y[79])+(0-Y[79]);


Yn[80]=(Y[90]-Y[80])+(Y[81]-Y[80])+(Y[70]-Y[80])+(0-Y[80]);

Yn[81]=(Y[80]-Y[81])+(Y[91]-Y[81])+(Y[82]-Y[81])+(Y[71]-Y[81]);
Yn[82]=(Y[81]-Y[82])+(Y[92]-Y[82])+(Y[83]-Y[82])+(Y[72]-Y[82]);
Yn[83]=(Y[82]-Y[83])+(Y[93]-Y[83])+(Y[84]-Y[83])+(Y[73]-Y[83]);
Yn[84]=(Y[83]-Y[84])+(Y[94]-Y[84])+(Y[85]-Y[84])+(Y[74]-Y[84]);
Yn[85]=(Y[84]-Y[85])+(Y[95]-Y[85])+(Y[86]-Y[85])+(Y[75]-Y[85]);
Yn[86]=(Y[85]-Y[86])+(Y[96]-Y[86])+(Y[87]-Y[86])+(Y[76]-Y[86]);
Yn[87]=(Y[86]-Y[87])+(Y[97]-Y[87])+(Y[88]-Y[87])+(Y[77]-Y[87]);
Yn[88]=(Y[87]-Y[88])+(Y[98]-Y[88])+(Y[89]-Y[88])+(Y[78]-Y[88]);

Yn[89]=(Y[88]-Y[89])+(Y[99]-Y[89])+(Y[79]-Y[89])+(0-Y[89]);


Yn[90]=(Y[91]-Y[90])+(Y[80]-Y[90])+(0-Y[90])+(0-Y[90]);

Yn[91]=(Y[90]-Y[91])+(Y[92]-Y[91])+(Y[81]-Y[91])+(0-Y[91]);
Yn[92]=(Y[91]-Y[92])+(Y[93]-Y[92])+(Y[82]-Y[92])+(0-Y[92]);
Yn[93]=(Y[92]-Y[93])+(Y[94]-Y[93])+(Y[83]-Y[93])+(0-Y[93]);
Yn[94]=(Y[93]-Y[94])+(Y[95]-Y[94])+(Y[84]-Y[94])+(0-Y[94]);
Yn[95]=(Y[94]-Y[95])+(Y[96]-Y[95])+(Y[85]-Y[95])+(0-Y[95]);
Yn[96]=(Y[95]-Y[96])+(Y[97]-Y[96])+(Y[86]-Y[96])+(0-Y[96]);
Yn[97]=(Y[96]-Y[97])+(Y[98]-Y[97])+(Y[87]-Y[97])+(0-Y[97]);
Yn[98]=(Y[97]-Y[98])+(Y[99]-Y[98])+(Y[88]-Y[98])+(0-Y[98]);

Yn[99]=(Y[98]-Y[99])+(Y[89]-Y[99])+(0-Y[99])+(0-Y[99]);

//alles werte filteren.
 for T=0 ... 99
  {
 Ya[T]=(Ya[T]/1.02)+(Yn[T]/40);
 Y[T]=Y[T]+Ya[T];

   }
P=Y[5];
lcdext.goto(2, 5);
lcdext.zahl(P);

 }
}

Was ist das denn für ein lustiger Filter?

c-controll ide ist eine Mischung aus C, C++, Pascal und Basic und wird
zur Laufzeit vom Betriebssystem interpretiert (und ist dementsprechend
langsam).
Für Spezialanwendungen, die schnel ablaufen mussen, ist es
unumgänglich, den Prozessor direkt zu programmieren.

Um wieviel schneller soll das ganze denn laufen?

Also ich sehe da schon im Code ne ganze Menge möglichkeiten.
Bsp:
Yn[0]=(Y[1]-Y[0])+(Y[10]-Y[0])+(0-Y[0])+(0-Y[0]);
Klammern auflösen und Operanden zusammenfassen sollte schon einiges
Bringen.
Yn[0]=Y[1]+Y[10]-4*Y[0]
was soll das für ein Filter sein?
Wenn du statt Float Fixkomma benutzen würdest sollte das auch eine
wesentliche Beschleunigung bringen.

Den filter hab ich fruher genutst fur ein 64k demo zu basteln.
Ich habe den muziek programmiert, also hatte ich im 1998 al ein
softsynth. Auch mache ich musiek, hab ein kleine studio hier.

Also es kan int bleiben bis es durch den filter geht.
Ein int/1.02 ist immer int/1.
Hab es mal mit int versucht, aber es wird ein paar maal sneller.

Ich denke dass ich 10x snellere oder 100x snellere uP.
Die preise muss rund die 100euro bleiben fur die uP.
Unt es muss ein site geben der alles deutlich erzelt wass ich muss
machen.(der c-controll site steht zb. welche betrieb systeme und alle
andere muss machen, die conrad site habe ich nichts an).

Der c164 16bit von infineon/siemens ist ja snell, bin mit ein
micro-controll angefangen.
Also wass raten ihr mich an?
Assembly code hab ich keine lust in, hab ich niemals getan.


vielle grusse bart

Viellecht ist der 'AT91SAM7S64 ARM Entwicklungsplatine' etwas.
Der 60mhz unt 32bit sprecht mich an.
Kan jemant mir den anraden, unt welche in der grupe.
Unt was muss ich dabei noch kaufen(software unt so...)

grusse bart