avr-libc, Bootloader, CodeVision

[Mark (Gast)]

Hallo,

ich bin gerade bei mich durch den Artikel:
http://www.mikrocontroller.net/articles/AVR_Bootloader_in_C_-_eine_einfache_Anleitung
zu arbeiten

Die 2 ersten Punkte:
Der "Hallo Welt" - Bootloader
Die Test-Anwendung
habe ich bereits geschaft.

Nun hänge ich aber etwas planlos an dem Punkt:
"Um in den Flash zu schreiben, werden wir Makros aus der boot.h der 
avr-libc verwenden. Hier findet man alle Werkzeuge, die wir brauchen"

Ich programmiere mit CodeVisionAVR, und müsste jetzt irgendwo 
wahrscheinlich die beschriebene avr-libc herunterladen und einbinden.

Aber wo bekomme ich diese her, und wie bindet man sie richtig ein.
Lässt sich die avr-libc den überhaupt so einfach in CodeVision 
verwenden?

Danke für alle hilfreichen Tipps.
mfg
Mark

[Kali (Gast)]

Das wird ein Problem. Die avr-libs ist für die Verwendung mit gcc 
gedacht, nicht für Codevision.

In dem Artikel wird ja auch ausdrücklich auf die nötige Software 
verwiesen:

Zitat:
Für den Artikel werden folgende Software-Pakete benötigt:

    aktuelles AVR Studio (hier verwendet: AVR Studio v4.18)
    aktuelles WinAVR (hier verwendet: WinAVR20100110)
    PuTTY als serielle Konsole (Version v0.6)

Nix von Codevision zu sehen.

[Mark (Gast)]

Danke für die Information, dies war mir bewusst.

Nichts desto trotz würde ich gerne mich mit dem Thema Bootloader und 
Codevision beschäftigen. Und irgendwo muss man ja anfangen.

Ich dachte mir vielleicht wenn ich die entsprechenden Dateien finde. 
(boot.h und boot.c) könnte man diese ja an die Codevision Besonderheiten 
anpassen?

mfg
Mark

[Kali (Gast)]

> Und irgendwo muss man ja anfangen.

Besser nicht "irgendwo" anfangen, besonders nicht mit einem Text der 
sich auf gcc und avr-libc bezieht und dann Codevision verwenden.

Theoretisch ist es sicherlich möglich, die avr-libc auf Codevision zu 
portieren. Es wäre günstig zu wissen, wieviele und welche Erfahrungen Du 
in C, in der Portierung von Code zwischen Compilern und in der 
Programmierung allgemein hast. Unter ein paar Jahren kannst Du das, 
denke ich, nicht leisten.

Die Alternative wäre mal mit Google und den Stichworten "Codevision 
Bootloader" zu suchen.

[Mark (Gast)]

schade, )-:
dann ist hier wohl eher Schluss für mich.

Aber wenigstens hat das mit den hin und her springen zwischen den 2 
Programmen geklappt.
(-:

[Kali (Gast)]

> dann ist hier wohl eher Schluss für mich.

Nicht unbedingt. Nur solltest Du spezifischer fragen. Ein "Kochrezept" 
gibt es hier eben nur in Bezug auf gcc und avrlibc.

Problem ist, das Deine Vorkenntnisse nicht einzuschätzen sind und Deine 
anderen Fragen hier darauf hindeuten, das Du Kochrezepte brauchst und 
wenig Vorkenntnisse hast. Dann würde man eigentlich erwarten, das Du 
Google benutzt und mit spezifischen Fragen kommst, aber das geschah auch 
nicht.

Es bleibt also eine Rundumfrage à la "Wie kriege ich die Beispiele für 
avr-libc | gcc unter Codevision zum laufen und das erfordert doch schon 
einiges an Vorwissen und Erfahrungen insbesondere mit den Erweiterungen 
von gcc und Codevision das man Dir hier nicht in zwei Sätzen vermitteln 
kann.

Du wirst Dich intensiv in gcc, codevision, avr-libc und Bootloader 
einarbeiten müssen. Dabei helfen wir Dir gerne, aber wiegesagt, 
vorzugsweise bei spezifischen Fragen.

[Ignatz-Finn (Gast)]

@Mark,

hast Du schon mal auf der hpinfotech Seite geschaut? Da sind ja auch 
bootloader portierungen (download).

IF

[Mario G. (mario)]

Hallo Mark, nun werfe nicht gleich die Flinte ins Korn (Ich habe den 
Artikel geschrieben).

Die die avr-libc opensource ist, kannst du dir die Makros auch 
anschauen.
In der Doku der Lib ist genau beschrieben was die Markos machen, schau 
mal hier: 
http://www.nongnu.org/avr-libc/user-manual/group__avr__boot.html

Es sollte kein Problem sein, dieses Markos/Funktionen und CodeVision 
nachzubauen. Evtl. kann auch ein Studium des Datenblatts des Controllers
helfen :)

Poste mal eine Lösung wenn du hast :)

[Mark (Gast)]

Hallo,

versuche gerade als erster die Funktion:
"#define boot_page_erase (   address ) 
__boot_page_erase_normal(address)
Erase the flash page that contains address."
umzusetzen.

Nach einigen Rescherschen im Datenblatt und hier im Forum hab ich 
folgendes geschafft.

register unsigned int    CurrentAdress       @0x0006; //CurrentAdress in Register 6 speichern

void DO_SPM(void)
{
     #asm
     WAIT_SPM:
          in   r16,0x37;           //SPMCR in Register r16 einlesen   37= Address von SPMCR, passt für ATmega32 
          sbrc r16,0x01;           //Skip if Bit in Register is Cleared
          rjmp WAIT_SPM;
          out  0x37,r17;           //schreibe in SPMCR-Register und führe aus
          spm;
     #endasm
} 

void PAGE_ERASE(unsigned int adress)
{

     CurrentAdress = adress;  
     //Löscht Page die in PAGE-Adresse des Z-Pointer(Z6...Z12) steht 
     #asm   
          movw r30,r6; //move  CurrentAddress to Z pointer  
          ldi  r17,0x03; //Bit 0 – SPMEN: Store Program Memory Enable, Bit 1 – PGERS: Page Erase 
     #endasm     
     DO_SPM();
}




//Aufruf im Hauptprogramm
   PAGE_ERASE(0x00);

Wie "Bild1" im Anhang zeigt löscht er mir auch die ersten 128 Bytes also 
die erste Page.

Jetzt möchte ich als nächsten Test aber versuchen die 2te Page zu 
löschen.
Welche Adresse muss ich den hierfür vorgeben?
Irgendwie löscht er mir bis jetzt immer nur die erste Page.

[Mark (Gast)]

ok einfach 0x80 vorgeben. also 128.

Das dürfte doch nun die gleiche Funktion sein wie die Funktion: 
"boot_page_erase" aus der avr-libc oder?

[Mark (Gast)]

Hallo die Herren,

hätte mal zwischendurch eine Verständnisfrage:

Auszug aus einer HEX.Datei:

:040000000C946800F4
:100004000C9400000C9400000C9400000C9400006C
:100014000C9400000C9400000C9400000C9400005C
:100024000C9400000C9400000C9400000C9400004C
:100034000C9486000C9400000C94B8000C940000FE
:100044000C9400000C9400000C9400000C9400002C

=

:04an 0000adr 00ty 0C 94 68 00 F4Pr
:10an 0004adr 00ty 0C 94 00 00 0C 94 00 00 0C 94 00 00 0C 94 00 00 6CPr
:10an 0014adr 00ty 0C 94 00 00 0C 94 00 00 0C 94 00 00 0C 94 00 00 5CPr
:10an 0024adr 00ty 0C 94 00 00 0C 94 00 00 0C 94 00 00 0C 94 00 00 4CPr
:10an 0034adr 00ty 0C 94 86 00 0C 94 00 00 0C 94 B8 00 0C 94 00 00 FEPr
:10an 0044adr 00ty 0C 94 00 00 0C 94 00 00 0C 94 00 00 0C 94 00 00 2CPr
:10an 0054adr 00ty 10 27 E8 03 64 00 0A 00 01 00 00 10 00 01 10 00 EAPr
:10an 0064adr 00ty 01 00 0A 0D 48 69 65 72 20 69 73 74 20 64 61 73 24Pr

ist dann folgende befüllung eines PAGE_BUFFERs korrekt?

unsigned char PAGESIZE    = 64; 
unsigned char PAGE_BUFFER[PAGESIZE*2]    @0x008A;

     PAGE_BUFFER[0]=0x0C; 
     PAGE_BUFFER[1]=0x94;
     PAGE_BUFFER[2]=0x68;
     PAGE_BUFFER[3]=0x0C;
     PAGE_BUFFER[4]=0x94;
     PAGE_BUFFER[5]=0x00;
     PAGE_BUFFER[6]=0x00;
     //usw.

???

[Mark (Gast)]

ach ne, hier stimmt was nicht.
Irgentwie verwirren mich die ganzen word Byte hex und dec und bin 
Formate gerade etwas.

[Mark (Gast)]

So nochmals eine Zusammenfassung des derzeitigen Standes:

Ausgangszustand des Flash:
siehe Bild0

Beim Empfang des Zeichens "l" soll die erste Page gelöscht werden:
i.0. siehe Bild1

Beim Empfang des Zeichens "w" soll die erste Page wieder mit dem 
PAGE_BUFFER beschreiben werden. (Den PAGE_BUFFER steht erstweils noch 
fix im Code):
n.i.O siehe Bild2

Könnte vielleicht wer von euch mal über den Code schauen und mir Tipps 
geben woran außer meiner Unfähigkeit es scheitert. Danke

void REENABLE_RWW(void);
void DO_SPM(void);
void PAGE_ERASE(unsigned int);
void READ_COM_2_PUFFER(void);
void RAM_2_TEMP_PAGE(void);
void PAGE_WRITE(void);

#pragma regalloc-        /* Deaktivierung der automatischen Vergabe von Adressen an Variablen*/
register unsigned int    daten                      @0x0002;
register unsigned int    CurrentAdress              @0x0006; //CurrentAdress in Register 6 speichern
unsigned int             j                          @0x0068;
unsigned char            PAGE_BUFFER[128]           @0x008A;
#pragma regalloc+        /* Aktivierung der automatischen Vergabe von Adressen an Variablen*/



void DO_SPM(void)
{
     #asm
     WAIT_SPM:
          in   r16,0x37;            //SPMCR in Register r16 einlesen   37= Address von SPMCR, passt für ATmega32 
          sbrc r16,0x01;            //Skip if Bit in Register is Cleared 
                                    //The SPMEN bit will auto-clear upon completion of an SPM instruction,
                                    //or if no SPM instruction is executed within four clock cycles. During page erase and page write,
                                    //the SPMEN bit remains high until the operation is completed.
          rjmp WAIT_SPM;
          out  0x37,r17;           //schreibe in SPMCR-Register und führe aus
          spm;
     #endasm
} 

void PAGE_ERASE(unsigned int adress)
{

     CurrentAdress = adress;  
     //Löscht Page die in PAGE-Adresse des Z-Pointer(Z6...Z12) steht 
     #asm   
          movw r30,r6; //move  CurrentAddress to Z pointer  
          ldi  r17,0x03; //Bit 0 – SPMEN: Store Program Memory Enable, Bit 1 – PGERS: Page Erase 
     #endasm     
     DO_SPM();
}


void REENABLE_RWW(void)
{
     #asm("ldi r17,0x11");    //Bit 0 – SPMEN: Store Program Memory Enable, Bit 4 – RWWSRE: Read-While-Write Section Read Enable
     DO_SPM();
}

 

void READ_COM_2_PUFFER(void)
{
     //Bereit zum Empfangen
     printf("\n\rDaten werden empfangen");
     //for(j=0;j<(PAGESIZE*2);j++)
     //{
     //   PAGE_BUFFER[j]=getchar();
     //}    
     
     PAGE_BUFFER[0]=0x0C; 
     PAGE_BUFFER[1]=0x94;
     PAGE_BUFFER[2]=0x68;
     PAGE_BUFFER[3]=0x00; //zeile1
     PAGE_BUFFER[4]=0x0C;
     ...
     PAGE_BUFFER[127]=0x6F;
                                  
}



void RAM_2_TEMP_PAGE(void)
{
     for(j=0;j<128;j++)
     {    
          daten=PAGE_BUFFER[j]+256*PAGE_BUFFER[j+1];   //schreibt wort in registerpar r3+r2      
          #asm("movw  r0,r2");                         //kopiert wert r3+r2 in r1+r0
          #asm("ldi r17,0x01");                        //If only SPMEN is written, the following SPM instruction will store the value in R1:R0 in the temporary page buffer addressed by the Z-pointer.
          DO_SPM();
          #asm("adiw r31:r30,2");                      //Addiert +2 in Z-Register-> Pageadresse
     }  
} 


void PAGE_WRITE(void)
{
     #asm
          movw r30,r6;   //move  CurrentAddress to Z pointer  
          ldi r17,0x05;  //Bit 0 – SPMEN: Store Program Memory Enable, Bit 2 – PGWRT: Page Write
     #endasm
     DO_SPM();
}



void main(void)
{
do
      {
        if(rx_counter>=1)  
        {
            c = getchar();  
             
            switch((unsigned char)c)
            {
                 case 'q': 
                flag=0;
                    printf("\n\rVerlasse den Bootloader!");
                    break; 
                      
                  case 'l':  
                    printf("\n\rLösche Page 0x0004");                      
                    //Page löschen  
                    PAGE_ERASE(0x0); 
                    //Reaktivierung des RWW-Bereichs
                    REENABLE_RWW();     
                    break;
                    
                  case 'w':                
                    //Daten aus serielle Schnittstelle lesen und in Array speichern
                    READ_COM_2_PUFFER();
                    //Von Array in temporären Pagespeicher speichern       
                    RAM_2_TEMP_PAGE();
                    //Page schreiben
                    PAGE_WRITE();                  
                    //Reaktivierung des RWW-Bereichs
                    REENABLE_RWW();
                    break;
                    
                    
                    
                 default:
                    printf("\n\rDu hast folgendes Zeichen gesendet: ");
                    printf("%c",c);         
                    break;
            }
        }
}

[Mark (Gast)]

Ich denke ich habe einen kleinen Fehler gefunden:

j immer um 2 erhöhen, da ja pro Durchlauf ein Wort übergeben wird

void RAM_2_TEMP_PAGE(void)
{     
     for(j=0;j<128;j+=2)
     {    
          daten=PAGE_BUFFER[j]+256*PAGE_BUFFER[j+1];   //schreibt wort in registerpar r3+r2      
          #asm("movw  r0,r2");                         //kopiert wert r3+r2 in r1+r0
          #asm("ldi r17,0x01");                        //If only SPMEN is written, the following SPM instruction will store the value in R1:R0 in the temporary page buffer addressed by the Z-pointer.
          DO_SPM();                                    //The LSB of the Z-pointer is ignored.
          #asm("adiw r31:r30,2");                      //Addiert +2 in Z-Register-> Pageadresse
     }  
}

leider funktioniert das Schreiben einer Seite trotzdem nicht. )-: