Bootloader Version

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

    • Bootloader Version

      Hi,

      Ich nutze viel den Bootloader von MCS allerdings ein bisschen abgewandelt. Nun suche ich nach einer Möglichkeit von meinem Programm aus die Version vom Bootloader zu erfragen.

      Ich denke mal der Bootloader muss an einen bestimmten Speicherbereich die Nummer eintragen und mein Programm ließt diesen Speicherbereich aus.

      Bitte um ein paar Denkanstöße ob so was gehen könnte.

      Gruß, Martin
    • Michael wrote:

      Meinst du den EEprom?
      Nein, Flash.

      Danke für den Link. Da steht:" Es lässt sich aber auch zur Speicherung von Daten nutzen (z. B. Texte für ein LCD). Vom laufenden Programm aus kann man das ROM normalerweise nur lesen, nicht beschreiben." Dann sollte es doch funktionieren. Bootloader mit ISP mit Version an bestimmte Speicheradresse. Mit normalem Programm diese Adresse lesen. Stelle ich es mir zu einfach vor?
    • nach meinem Verständnis lädt er mit
      ldi ZL, LOW(daten*2)
      ldi ZH, HIGH(daten*2)
      die Adresse in den Pointer und mit
      lpm
      den dort stehenden Wert nach R0, wo er dann weiterverarbeitet werden kann.

      Im Bootloader musst du halt die Daten an die richtige Stelle legen.
      Mit org?

      Ich bin nicht wirklich firm mit Assembler, da können dir hier sicher andere besser helfen.
      @Galahat vielleicht?
    • Ich denke schon, dass man das über den Bootloader abwickeln kann.
      Der Bootloader selbst ist in der Bascomhilfe mit dem Begriff "$Loader" zu finden.
      Oder diesen Link.

      Der Quellcode ist weiter unten auf der Seite abgebildet.

      In Grunde kannst du den Bootloader erweitern, der dann bei einem bestimmten Byte-Befehl (der noch nicht vergeben sein darf), die Version zurück liefert.
      Schau dir mal die Hauptschleife an.
    • Falls du doch keine Lösung hast, hab ich einen Vorschlag.

      Im Bootloader legst du am Ende des Codes eine Datazeile an, der du ein Label voranstellst.

      BASCOM Source Code: Ergänzung 1 im Bootloader

      1. ' Hier das Label, in dem beliebeige Daten für das Anwendungs-Programm stehen können.
      2. DataForProgrammAccess:
      3. Data 0123% ' Version 1.23


      In der Hauptschleife wird ja irgendwie festgestellt, dass der Bootloader beendet werden soll.
      Da müsste also an diversen Stellen "Goto _Reset" angegeben sein.

      Der Trick ist nun, dass du von dem Ausführen von "Goto _Reset" die Adresse des Labels ermittelst und auf dem HWStack ablegst.

      BASCOM Source Code: Ergänzung 2 im Bootloader

      1. Restore DataForProgrammAccess ' Adresse lesen
      2. !PUSH r8 ' und auf HWStack sichern
      3. !PUSH r9
      4. Goto _reset ' Bootloader verlassen

      Damit übermittelt der Bootloader beim Verlassen die Adresse per Stack auf das Label. Darin könnten auch noch weitere Daten stehen.

      So.
      Wie kommt man nun an diese Daten ran vom Anwendungsprogramm?
      Das ist auch einfach.

      Man legt eine Variable an, die die Daten aufnimmt. Im Beispiel eine Integer-Variable für die Version des Bootloaders.
      Dann holt man die Adresse vom Stack und liest mit Read den Wert der Version ein.

      BASCOM Source Code: Im Anwendungsprogramm.

      1. ' In deinem Anwendungs-Programm fügst du am Anfang folgendes ein und
      2. ' holst dir die Daten vom Bootloader
      3. Dim BootloaderVersion as Integer
      4. !POP r9 ' Adresse auf Data's im Bootloader
      5. !POP r8
      6. Read BootloaderVersion
      7. ' und schon hast du die Version im Programm.

      Das sollte funktionieren, solange du keine Lockbits setzt, die den Zugriff per LPM auf den Flash und den Bootloaderbereich unterbinden.
      Wenn du im Hauptprogramm die 2 Byte nicht vom HWStack holst, läuft dein Programm trotzdem. Es werden lediglich die 2 Bytes mehr belegt.
      Und dann gibt es noch was zu beachten: Das geht nur mit Controllern bis 64k Flash, weil das RAMPZ nicht berücksichtigt wird. Könnte man aber erweitern.

      Probier's aus und berichte ob klappt.

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

    • Danke für die Tipps. Hatte mich damit noch nicht beschäftigt...


      Mitch64 wrote:

      Der Trick ist nun, dass du von dem Ausführen von "Goto _Reset" die Adresse des Labels ermittelst und auf dem HWStack ablegst.
      Geht das nicht einfacher? Wenn ich an dem Bootloader eine Data Zeile anhänge wird die doch immer an die gleiche Adresse geschrieben. Ich sollte doch nur diese Adresse kennen und dann im Anwenderprogramm diese Adresse lesen. Dann brauche ich den Stack ja nicht.
    • Pac-Man wrote:

      Geht das nicht einfacher?
      Kommt drauf an, was du unter einfacher verstehst.

      Du kannst die Datazeile natürlich auch am Anfang des Bootloaders als erstes einfügen und mit einem !RJMP das Label samt Data's überspringen.
      Die Adresse des Labels kannst du dann im Simulator 1x ermitteln und dir mal merken.

      Wenn du dann mit dem Programm auf diese Flashadresse zugreifen willst, musst du diese mit LPM abfragen und deine 2 Byte als Integer zusammen setzen.
      Alternativ zu LPM sollte auch CPeek gehen.
      Die Adresse musst du aber zuvor mit 2 multiplizieren (1x links shiften), damit du die Byteadresse im Flash hast.

      Mein Vorschlag aus #10 hat eben den Vorteil, dass du mit Basic-Befehlen relativ einfach an die Datazeilen rankommst.
      Dabei kann da in den Datazeilen auch noch mehr stehen wie Copyright, Datums etc.

      Das alles mit LPM abfragen geht auch, das ist aber elktrischer als mit Read zu hantieren.

      Ein ganz anderer Weg wäre über das interne EEProm zu gehen.
      Deine Daten kannst du ja am Ende des EEProms ansiedeln. Wenn der Bootloader dann ausgeführt wird, muss der dort schauen, ob da schon die korrekte Version steht, und wenn nicht aktialisieren.

      Wenn dann das Hauptprogramm startet, kannst du diese EEProm-Zellen wieder auslesen.

      Irgendwo musst du halt die Daten speichern.

      Mit Tricks geht es vermutlich auch über das SRAM.
    • Ich habe eben mal ein Test im Simulator gemacht.

      Wenn man ein Anwender-Programm startet (Einzelschritt), bis man am 1. Befehl ankommt,
      bleiben die Register r7 bis r23 unverändert. D.h die Initialisierung (Stack, RAM auf 0 setzen etc.) verändert diese Register erst mal nicht.
      Das kann man sich zu Nutze machen.

      Im Bootloader kannst du also auf das Pushen der Register r8, r9 verzichten.
      Musst also nur den Restore <Labelname> ausführen. Das setzt die Register r8 und r9. Dann mit Goto _Reset den Bootloader verlassen.

      Im Anwendungsprogramm dann einfach mit Read die Version auslesen.
      Das solltest du aber am Anfang machen, damit du sicher sein kannst, dass die Register nicht verändert werden durch irgendwelche Befehle.

      BASCOM Source Code: Im Bootloader

      1. Do
      2. ' wenn der Bootloader beendet werden soll, weil das Programm
      3. ' vollständig übertragen wurde oder keine Übertragung statt findet (Timeout),
      4. ' wird normalerweise an die Adresse 0 gesprungen mit
      5. ' Goto _reset
      6. ' Bevor man das tut, Liest man die Adresse des Labels mit Restore ein
      7. Restore DataForProgrammAccess ' Adresse lesen
      8. Goto _reset ' Bootloader verlassen
      9. ' Das wars im Bootloader
      10. Loop
      11. ' Hier das Label, in dem beliebeige Daten für das Anwendungs-Programm stehen können.
      12. DataForProgrammAccess:
      13. Data 0123% ' Version 1.23
      Display All

      BASCOM Source Code: In deinem Anwender-Programm

      1. ' In deinem Anwendungs-Programm fügst du am Anfang folgendes ein und
      2. ' holst dir die Daten vom Bootloader
      3. Dim BootloaderVersion as Integer
      4. Read BootloaderVersion
      5. ' und schon hast du die Version im Programm.
      Ich denke einfacher geht's kaum noch!

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

    • Mitch64 wrote:

      Alternativ zu LPM sollte auch CPeek gehen.
      Die Adresse musst du aber zuvor mit 2 multiplizieren (1x links shiften), damit du die Byteadresse im Flash hast.
      Bastele schon eine Weile mit CPeek kriege aber nicht das gewünschte Ergebnis. Ich möchte nur ein paar Bytes am Anfang des Bootloaders lesen um zu sehen ob ich es richtig mache.

      Bootloader fängt bei FC00 an also lese ich ab 64512. Ich multipliziere mit 2 und lese ein. Wenn ich nun das eingelesene mit meinem Hexmonitor suche, finde ich es aber nicht...

      Source Code

      1. Local X As Dword : X = 0
      2. Local Y As Dword : Y = 0
      3. Local Element As Byte
      4. For X = 64512 To 64532
      5. 'For X = 64818 To 64834
      6. Y = X * 2
      7. Waitms 50
      8. Element = Cpeek(hex(y))
      9. Print#pc , "@" ; "> " ; Hex(y) ; " " ; Hex(element) ; "<" ; Chr(13)
      10. Reset Watchdog
      11. Next X
      Display All
    • Hab da eine Verschlüsselung eingebaut... Aber ich hänge am Ende eine Datazeile an.


      Source Code

      1. Do_spm:
      2. Bitwait Spmcsr.0 , Reset ' check for previous SPM complete
      3. Bitwait Eecr.1 , Reset 'wait for eeprom
      4. Z = Page 'make equal to page
      5. Shift Z , Left , Maxwordshift 'shift to proper place
      6. Z = Z + Wrd 'add word
      7. ! lds r30,{Z}
      8. ! lds r31,{Z+1}
      9. #if _romsize > 65536
      10. ! lds r24,{Z+2}
      11. ! sts rampz,r24 ' we need to set rampz also for the M128
      12. #endif
      13. Spmcsr = Spmcrval 'assign register
      14. ! spm 'this is an asm instruction
      15. ! nop
      16. ! nop
      17. Return
      18. ' Hier das Label, in dem beliebeige Daten für das Anwendungs-Programm stehen können.
      19. DataForProgrammAccess:
      20. Data "irgendwas" ' Version 1.23
      Display All
      das Irgendwas finde ich in der BIN auch an Adresse 1FD32.

      Ich möchte gerne den CPeek Befehl verstehen.