Belegte Flash-Speicher (romimage) ermitteln

    This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

    • Belegte Flash-Speicher (romimage) ermitteln

      Hallo Leute,
      unter Kompilier-Ergebnisse (Show Report) kann man raus finden belegten Flash-Speicher (romimage).
      Wie kann ich das ermitteln bzw berechnen?

      Mit freundliche Grüße,

      Patrick_cpp
    • So ganz kann ich dir nicht folgen, was genau du berechnen willst.
      Willst du anhand der erstellten Dateien herausfinden wie viel Flash belegt ist?
      Beim Kompilieren wird dir ja die Auslastung des Speichers in Prozent angezeigt und daraus kannst du dir den freien und beschriebenen Flash ableiten.
      Ganz einfacher Dreisatz.

      Beispiel Mega8

      Display Spoiler

      8KB = 100%
      x = 2%

      x = 8 * 2 / 100 = 0,16KB
      Rest = 7,84KB
      Eine Lösung habe ich nicht, aber mir gefällt Ihr Problem.
    • Ich denke, dass man das nicht so ohne weiteres "berechnen" kann.
      Der Compiler wiederum kann das sehr wohl weil der "weiß" ja wie viel Platz im Flash jeder einzelne Befehl "verbraucht".
      Du kannst nur im zugrundeliegende Report-File diese Information entnehmen (was anderes wird Show-Report auch nicht machen.
      Ich habe auch ein Tool geschrieben, welches dieses Report-File "zerlegt" und auch neben den "einfachne" Informationen relativ genau auch den RAM-Bedarf für die verwendeten Variablen übersichtlich aufzeigt. Aber auch das nimmt in erster Linie nur die Informationen des Report-Files und versucht auf genauere Werte zu kommen wenn Mehrdimmensionale Variablen verwendet werden (dazu zerlege ich aber auch das BAS-File).
    • Es gibt ein Programm wie viel HW-, SW-Stecks und Framesize genutzt wird ($HWCHECK, $FRAMECHECK, $SOFTCHECK).



      Wenn ich Ahnung hätte mit Assembler-Programmierung, könnte es selbst Funktion programmieren.

      Ich wollte mal unter erfahrenden Bascom- Nutzer bzw Bascom- Programmierer eine Idee hat.
      Es reicht mir schon letzten Freien Blöcke zu ermitteln.

      Gruß,
      Patrick_cpp
    • Ich weiß nicht, ob das dir hilft. Im code-explorer wird unter 'info' ja der stack angegeben, der mutmaßlich gebraucht wird. Was fehlt ist der Platz für push und pop im Falle eines interruptaufruf im hwstack. Die (32 byte) muss man dazu rechnen
      codeexplorer.PNG
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Die Startadresse für die Stacks ist recht einfach zu ermitteln:
      intern legt der Compiler eine Konstante "_gstrbuf" an, die auf den Start vom Framespace zeigt:

      BASCOM Source Code

      1. Const End_of_free_ram = _gstrbuf - 1

      Den Anfang kann man leider nicht programmtechnisch ermitteln, da kann man nur nach dem kompilieren den Report analysieren (Options->Compiler->Output->Show internal Variables nicht vergessen)
    • Wenn man die stacks unbedingt selbst berechnen will, hier sind paar Anleitungen
      avrhelp.mcselec.com/memory_usage.htm
      Ich halt mich an die Angaben im codeexplorer, korrigiere den hwstach bei interrupts und geb' jeweils noch paar 'Angstbytes' drauf.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • patrick_cpp wrote:

      Wie kann ich das ermitteln bzw berechnen?
      Das Programm selber soll wissen wieviel Platz noch ist? Um selber was reinzuschreiben? Eeprom zu klein?
      Den von Bascom bekannten Wert als Konstante ablegen. Alles darüber ist ungenutzt.
      Oder nach jedem Neustart den noch freien Bereich erkennen? Vom Ende rückwärts nach FF prüfen. Dann ist er aber irgendwann ganz voll.
      Oder gehts ums Ram? einfach eine Variabe der benötigten Größe anlegen und nicht nutzen dieser Bereich bleibt dann frei.
    • Ich hätte da eine Idee.

      Es geht ja darum, das letzte Byte des ROM-Image, also vom Programm das im Flash liegt zu bestimmen.

      Ich Stand da auch mal vor dem Problem.

      Wenn man das zur Laufzeit des Programms ermitteln will, setzt man im Code nach der letzten Programmzeite ein Label.
      Das kann man z.B. progEnd nennen.
      Zur Laufzeit ermittelt man einfach die Adresse des Labels. Schon weiß man wo das 1. freie Byte im Flash ist.

      Noch ein Tip am Rande.
      Im Menü Optionen -> Compiler -> Output den Haken bei "Show internal variables" setzen und programm neu kompilieren.
      Dann im Menü Programmieren -> Ergebnis anzeigen (STRG-W) aufrufen.

      Da werden einige Systeminterne Variablen aufgelistet, die sehr interessant sind.
      Kaum macht man es richtig - und schon geht's!
    • Pluto25 wrote:

      Und das ist dann tatsächlich ganz am Ende? Immer? Oftmals stehen hinten die Werte der Zuweisungen.
      z.B. Textstring = "Das ist ein Text"
      Ich kann dir nicht ganz folgen.

      Nach der letzten geschriebenen Programmzeile ein Label plazieren.
      Nach dem Label folgt kein Code mehr (auch kein Textstring=irgendwas).

      Du kannst das gerne im Simulator ausprobieren, dir die Adresse berechnen lassen und im Flash-Abbild (Simulator) prüfen.
      Kaum macht man es richtig - und schon geht's!
    • Pluto25 wrote:

      Das Flash Abbild ist die Bin Datei. Im Simulator finde ich nur Ram und EEprom
      Ja.
      Das kannst du sehen, wenn du auf manuell programmieren gehst.
      Da kannst du den Flash einsehen.

      Bedenke aber es wird in Byte-Adressen angezeigt.

      Hier mal ein Code-Beispiel:

      BASCOM Source Code

      1. $Regfile = "m8def.dat"
      2. $Crystal = 4000000
      3. $HWStack = 32
      4. $SWStack = 20
      5. $Framesize = 30
      6. $Baud= 9600
      7. Dim ptrProgEnd as Word ' Variable nimmt Adresse des Label auf
      8. ptrProgEnd=LoadLabel(_progEnd) ' Word-Adrsse
      9. Shift ptrProgEnd,Left,1 ' in Byte-Adresse umrechnen
      10. Print hex(ptrProgEnd)
      11. End
      12. _progEnd:
      Display All
      Im Simulator laufen lassen, es wird dann die Hex-Adresse angezeigt.

      Dann manuell programmieren aufrufen und an der Adresse schauen. Ab da ist der Flash frei.

      Bootloader werden aber nicht berücksichtigt!
      Kaum macht man es richtig - und schon geht's!

      The post was edited 1 time, last by Mitch64 ().