Hallo zusammen, ich versuche mich gerade an der Progammierung eine HCs12. Ich wollte nun eine "Wait"-Funktion einfügen. Einfach eine For-Schleife die von einer bestimmten zahl runter zählt. Das Programm läuft, aber die Funktion wird anscheined nicht aufgerufen, also es wird quasi nicht gewartet. Hat jemand einen Tip, woran das liegen könnte? Vielen Dank. Gruß Maik
Hi, wenns wirklich nicht wartet, hast du möglicher weise in deiner For -Schleife nichts drin stehen. Und der Optimizer deines compilers wirft dann diese scheinbar sinnlose schleife einfach raus. Am besten du schreibst in die schleife etwas rein, wie z.B ein assembler "NOP". Dann wird das klappen. Marc989
ich habe das nun einmal wie folgt gemacht, aber auch dann wartet der nicht: for(ii=1; ii < zahl; ii++) { for(ii=1; ii < zahl; ii++) { _asm("NOP"); } _asm("NOP"); }
Ansonsten liegt der Fehler vielleicht in Zeile 12?! Ohne Code wird das nicht viel. Ein entsprechender Codeauszug wäre nett. Vielleicht hast ja nen gedanklichen Fehler drin? Schonmal kontrolliert, ob er überhaupt in die For Schleife reingeht? Z.B über UART senden, LED blinken lassen oder (im Idealfall) debuggen per Compiler und Breakpoint. Das geht doch recht easy mit dem HCS12, solang du diesen Programmer hast.
> for(ii=1; ii < zahl; ii++) > { > for(ii=1; ii < zahl; ii++) > { > _asm("NOP"); > } > _asm("NOP"); > } Wartet er gar nicht oder ist nur die Zeit zu kurz? Die äussere for-Schleife bewirkt hier nämlich gar nichts, weil ihre Endbedingung durch die innere for Schleife mit ausgelöst wird. -> 2 verschiedene Variablen benutzen.
Also zumindest di äußere For-Schleife kannst du dir schenken. Denn wenn er aus der inneren For Schleife raus geht, ist ii mit sicherheit schon größer als zahl. Somit wird deine äußere Schleife genau 1x aufgerufen. Btw: Wie groß ist "zahl" üblicherweise? Deine MCU läuft mit (laut mystischer Glaskugel) 16MHz. Da muss Zahl schon reichlich groß sein, dass du selber was mit warten bemerkst.
Hi, wenn du zwei mal ii als zähler nimmst, löscht die innerer schleife den wert der äußeren. Ich würde unterschiedliche variablen nehmen. Des weitern wäre noch interessant welcher Wert in Zahl steht und wieviel bittig die variable ist. (8-bit, 16 bit...) Marc989
Verdammt! Schonmal 2x in Folge zu langsam gewesen! Seid ihr schnell! :D
zahl wird mit 10.000 übernommen und ist als int definiert for(ii=1; ii < zahl; ii++) { for(jj=1; jj < zahl; jj++) { _asm("NOP"); } _asm("NOP"); }
... wait(10000); ... void wait(int zahl) { int ii, jj; for(ii=1; ii < zahl; ii++) { for(jj=1; jj < zahl; jj++) { _asm("NOP"); } _asm("NOP"); } }
10000 * 10000 Nops = 100000000, also 100 Millionen. Das sollte man bei 16 Mhz schon recht deutlich sehen. Schmeist dir das der Compiler immer noch raus?
vermutlich schon! im step by step springt er in die schleife aber beim normalen durchlauf scheint er den wait zu ignorieren
Dann musst du in der Schleife irgendwas anderes machen, was der Compiler nicht wegoptimieren kann. Eine Funktion aufrufen bei der der Compiler den Funktionsrumpf nicht sieht und daher nicht inlinen kann, ist zb. immer ein guter Kandidat: static void wait_1( int time ); static void wait_2(); void wait( int time ) { int i; for( i = 0; i < time; ++i ) wait_1( time ); } void wait_1( int time ) { int i; for( i = 0; i < time; ++i ) wait_2(); } void wait_2() { asm( "NOP" ); }
bist du sicher das dein int 16 bit gross ist? Ich programmiere oft mit 8Bit controllern und da ist das int eben nur 8 bit gross, also nur (0...255). dann könntest du so eine große zahl nicht reinladen. dann bliebe nicht mehr viel davon übrig. Weiss nicht mehr ob der HC12 8Bit oder 16Bit controller ist.
Wenn du ein oszilloskop an einen portpin hängst und innerhalb der schleife toggelst, hast du dann das signal? gruß marc
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.