Programmieren in C oder besser Assembler?!

Ich habe hier schon einiges über die Programmiersprachenfrage gelesen. Bei Bascom heißt es: Sehr einfach zu lernen, aber unflexibel. Zu Assembler schreiben die meisten das es genau die Sprache ist die der Controller umsetzt und auch 100% versteht. Zu C hab ich noch nicht so viel gelesen.
Ich selber mache momentan meinen Techniker in E-Technik Automatisierungstechnik und habe 1 Schuljahr C hinter mir. Ich hab mir zum testen mal alle drei Sprachen angeschaut. Bascom ist wirklich wie Basic und auf dem LCD (Ich hab das Myavr-Board) hat man im nu seinen Namen ausgegeben. Danach hab ich mir Assembler angeschaut, mir kam die Sprache irgendwie total komplex und undurchsichtig vor. <-- Sorry an die alten Hasen :-) . Zu guter letzt hab ich mir den Freewareeditor/compiler usw. Winavr runtergeladen und ein Lauflicht nach einem Tutorial hier im netz geschrieben.
Ich war gleich beeindruckt wie einfach das mit dem Makefile (mit dem passenden programm) usw. geht. Vor allem hab ich alle meine Schleifen (do, while usw.) mit denen ich mich eh schon auskenne. Ich denke ich habe meine entscheidung getroffen. Gibts irgendwas über C was mich davon abhalten sollte?! Ich habe mal gehört das die Programme in C mehr Platz brauchen als die die in Assembler geschrieben wurden, naja ich glaube diese Regionen werd ich nicht ereichen.

Eure Meinung würde mich echt interessieren.

PS: Im ersten Jahr haben wir jede Menge Grundlagen zum Atmega16 in der Schule gemacht, also um den Chip zu verstehen brauch ich nicht erst Assembler zu lernen :-)

Gruß vom Schweißfuß .. äh Moonwalker

Hallo Moonwalker,
bei mir wars so:
Bascom > C > Assembler! Ich fand Bascom irgendwie zu blöd! Denn immer solche Befehle bei denen man nicht weiß was im Controller wirklich passiert! Dann hab ich C angefangen! War aber au net so mein Ding und bin jetzt bei Assembler geblieben! Wenn man Assembler lernt dann muss man sich mit dem Chip auseinandersetzen!
Gruß Michi

hi

mit c kannst du sicher nicht so optimierte programme schreiben wie mit assembler (vorausgesetzt, du kannst wirklich asm programmieren). der grosse vorteil an c ist einfach, dass der code viel übersichtlicher, kompakter, einfacher verständlich, ... ist.

die paar prozent an performance, die du mit asm gewinnen kannst, brauchst du meist eh nicht, falls doch, kannst du immer noch die kritischen programmteile in asm und den ganzen rest in c erstellen.

cu

chris

also winavr-c ist schon klasse. habe meine ganzen sensoren am küchenbrettroboter damit geproggt. man lernt den avr richtig kennen. eine tolle sache . bascom hatte ich 6 monate dann kannte ich es schon auswendig, nur wusste ich nicht wie bascom den code hinbüffelt und wie du eingangs auch sagste bascom macht was es will, den code kann ich nicht beeinflussen, den prozessor kann man nicht kennenlernen. ich gehe meinen weg jetzt von fastavr zu asm. die ersten gehversuche waren aber mit winavr-c.
mfg pebisoft

ich sehe das ähnlich wie cavegn:
C ist idR ziemlich gut geeignet, du kannst recht portablen Code schreiben der auch in einem Jahr noch verständlich ist. Mit einem guten Compiler ist der Code auch gut optimiert, aber du weißt halt nie genau was der Compiler da rumoptimiert. IdR kann der das aber ziemlich gut, und wenn du nicht allzuviel Ahnung vom Prozessor hast besser wie der Mensch. Asm ist extrem prozessorspezifisch und nur dann wirklich das Mittel der Wahl wenn es zeitkritisch ist. Du kannst asm-Code maximal optimieren, aber dann musst du auch entsprechend viel Ahnung vom Prozessor haben.
Und: Finger weg von Basic.

avr-gcc macht einen guten Code. Teilweise kommt es auch drauf an, wie man Sachen hinschreibt und man erhält kompakteren Code oder schnelleren.
Wenn es wirklich zeitkritisch ist, kannst du auch sehr gut C mit asm kombinieren, den avr-gcc erzeugt lediglich Assembler und ruft dann intern den Assembler auf, den avr-as.
Du kannst also
- Assembler-Stückchen via inline asm in deinen Code einbauen. Wie das genau geht, steht in der Doku zur avr-libc.
- Du kannst ganze Module direkt in Assembler hinschreiben und den avr-as drüberrauschen lassen, evtl auch den Preprozessor. Die erzeugten Objekte bindet man wie gewohnt mit dem Linker zusammen.
inline asm sieht dann etwa so aus:

Code:

#define bit_count(_x) \ ({ \ unsigned char __p = 0; \ unsigned char __x = _x; \ asm volatile (\ "; %0 = bit_count (%1)" "\n\t"\ "0:" "\n\t"\ "lsr %1" "\n\t"\ "adc %0, __zero_reg__" "\n\t"\ "tst %1" "\n\t"\ "brne 0b" "\n\t"\ : "=&r" (__p), "=&r" (__x) \ : "1" (__x), "0" (__p));\ __p; \ })

Man kann also auch C-Variablen übergeben und einfach benutzen:
// a ist Anzahl gesetzter Bits in b
unsigned char a, b;
...
a = bit_count(b);