Atmega8515 programmieren?

[dg2ygq]

Hallo. Ich habe nun noch garkeine Ahnung von dieser Materie, möchte mich aber etwas damit beschäftigen.

Was ich brauche: ich brauche eine PU, welche mir 2 7-Segmentanzeigen steuert (zb von 00-99).
Gleichzeitig 8Bits, die je nach auf den 7Segmentanzeigen angezeigten Ziffern,
verschiedene Hi/Lo Zustände ausgeben.
Allerdings weichen die 8Bits von der 7Segmentanzeige völlig ab.
zB soll bei der Anzeige "30" der Wert "127" an den 8Bits ausgegeben werden.

Geschaltet soll die Anzeige und die 8 Ausgänge dann per UP/Down "Taste" werden.

Wie gesagt, ich habe davon noch garkeine Ahnung, möchte mich aber darin vertiefen!
Funktionert mein Vorhaben überhaupt mit einem 8515? Oder sind andere PUs besser geeignet?
Dann kommt die Sche mit dem Aufbauen und Programmieren, sowie die Frage nach Lektüre dazu.

Vielleicht könnt ihr mir ja einen Lichtblick vermitteln ?!

 

[Dirk]

Hallo,

wenn Du AVR-Mikrocontroller programmieren möchtest, eignet sich unter anderem AVRStudio (Assembler) und WinAVR (GNU C-Compiler). Es gibt einige einfache Programmierer zum selberbasteln, da würde ich einfach einmal mit google suchen, allerdings empfehle ich Dir ein kleines Entwicklungsboard (zB. STK500, Atmel) und einen Programmierer, wie den AVR-ISP mkII (Atmel), dann hast Du es bei Deiner Entwicklung einfacher.

Wenn Du den ATmega8515 einsetzen möchtest, kannst Du die Siebensegment-Anzeigen direkt ohne zu multiplexen an zwei Ports des Mikrocontrollers anschließen, dieser eignet sich also schon für Dein Projekt. Alternative wäre ein ATtiny2313, da dieser Mikrocontroller nur zwei I/O-Ports besitzt, müsstest Du allerdings die Anzeige multiplexen und ggf. die 8Bit-Ausgabe puffern (Latch).
Hat Dein Anzeigewert kein lineares Verhältnis zum 8Bit-Ausgabe-Wert, oder falls Du keine andere einfache mathematische Beziehung findest, eignet sich eine Tabellenadressierung, hier sind für zB. 100 Anzeigewerte (0..99) 100 8Bit-Werte im FlashMemory abgelegt, die durch den Befehl LPM adressiert werden.

Gruss
Dirk

 

[dg2ygq]

Hallo Dirk,
Erst mal ein dickes Dankeschön für deine schnelle Antwort!

Also Entwicklungsboard und Programmer wären schon angesagt ?! Ok, mach ich mal mal schlau, zum Glück hast du mir ja gleich Typen genannt (gar nicht leicht als Unwissender sich da rein zu finden).
Als ich das letzte mal so etwas gebastelt hatte, war mein c64 noch mein Freund. Die 8Bits gingen über den Userport, die Anzeige (2 7Segmente) übernahm der Monitor, die Up/Down-Funktion die Tastatur. Nur ist doch so ein C64 mit Monitor ziehmlich unhandlich *lach*

Die Anzeige von 0-99 überspringt einige Werte im Ausgang, arbeitet also nicht durchgehend. Die Anzeige soll genauer von 1-80 durchgehen, und dann bei 1 wieder anfangen, (bei "down" natürlich anders herum). Beim C64 hatte ich für jede Ziffer einen "Data-Wert" abgelegt.

Wie du sicher liest, ich kann mich dies bezüglich garnicht ausdrücken, weil das alles Neuland für mich ist.
Ich hoffe meine Fragen sind nicht zu "dumm", und mein Anliegen nicht zu übertrieben?!

Ich werde mich mal nach PU und Board umschauen. Da werden sicher noch so einige Fragen auf Dich (Euch) zu kommen (zB wie stell ich einige Ports auf "Out", die anderen auf "In". Aber ich denke mal da wird mir auch die genannte Software wenigstens etwas weiter helfen.

Hast du vielleicht noch eine Software Lösung für Linux parat ?

Eine Frage noch zu Ausgängen des 8515: Kann ich dort die 7Segmentanzeigen direkt anschließen, oder lieber über einen Transi schalten? Ich schätze dass jedes Segment gut und gern 20 - 30mA ziehen wird?!
Oder gibt es da "Treiber ICs" für, die mir die Arbeit erleichtern würden?

 

[Dirk]

Hallo dg2ygq,

du benötigst nicht unbedingt ein Entwicklungsboard, wenn du aber in Zukunft öfter programmieren möchtest, wird sich das schon lohnen, da du dich nicht jedesmal mit Lötarbeiten beschäftigen musst. Es gibt einige Programmierer, die fast nichts kosten, bzw. die du dir selber zusammenbasteln kannst. Wenn du dir einen besseren Programmierer zulegst, zum Beispiel den AVR-ISP mkII, sparst du dir ggf. das Basteln und bist sicherer, dass dein Programm richtig programmiert wird.

Ich würde an deiner Stelle mit der Programmierung in Assembler anfangen, da lernt man eher das Innenleben des Mikrocontrollers, wenn du dich allerdings bereits mit C auskennst, würde ich den WinAVR GCC-Compiler nehmen. Das ist auch Geschmacksache, der eine schwört auf Assembler, der andere auf C oder Pascal. Es kommt auch immer darauf an, was du für ein Projekt hast.

Du kannst hier im Forum ruhig Fragen stellen, dafür ist es ja da. Da das Forum noch neu ist, sind noch nicht so viele User aktiv bzw. Beiträge vorhanden, die dir weiterhelfen könnten, also einfach Fragen!
Eine Softwarelösung für Linux habe ich jetzt nicht direkt parat, es gibt aber die Möglichkeit den GCC-Compiler für Linux zu kompilieren.

Du kannst an die I/O-Ports des ATmega8515 direkt LED-Siebensegmentanzeigen anschliessen, du musst auf die maximal zulässigen Ströme achten. Atmel gibt hier folgendes an:

Although each I/O port can sink more than the test conditions (20 mA at VCC = 5V, 10 mA at VCC = 3V) under steady state
conditions (non-transient), the following must be observed:

• The sum of all IOL, for all ports, should not exceed 300 mA.
• The sum of all IOL, for ports B0 - B7, D0 - D7, and XTAL2, should not exceed 150 mA.
• The sum of all IOL, for ports A0 - A7, E0 - E2, and C0 - C7 should not exceed 150 mA.

Ich würde gleich Anzeigen nehmen, die ein bisschen weniger Strom benötigen (<=10mA/Seg), da du die Anzeigen nicht multiplexen musst, geht auch keine Helligkeit "verloren". Wenn du höhere Ströme Treiben möchtest, kannst du zum Beispiel ULN2803 (7 fach Darlington Array) verwenden.

Gruss
Dirk

 

[dg2ygq]

EntwicklungsBoard und Programmierer:

"Brauche" ich beide Gerätschaften? Oder kann man auf dem Entwicklungsboard schon prgrammieren? Bzw kann ich auf dem Programmierboard schon was "testen"?

Atmega8515:
Wieso will der Händler mit dem großen "C" 9€ für einen haben, und der Händler mit dem großen "R" bloss 2,50€ ?
Oder habe ich falsch geschaut, dass es unterschiedliche Typen sind?
Ob 8 oder 16Mhz macht nicht wirklich was aus; der c64 mit 4 Mhz kam schon damit klar
Der im 40Pol DIL-Gehäuse würde mir für meine Zwecke am besten zusagen.

Der Takt: muss ich dem 8515 eine Frequenz zuführen, oder macht der auch ohne Quarz bzw Quarzoszillator seinen Dienst?

 

[Dirk]

Wenn Du das STK500 Entwicklungsboard nimmst, benötigst Du keinen Programmierer. Ein AVR auf dem Board läßt sich dann über AVRStudio programmieren. Das STK500 unterstützt schon eine Menge AVRs in verschiedenen DIP-Größen, ich glaube auch den ATmega8515. Zusätzlich gibt es noch verschiedene Adapter, so dass Du auch AVRs in anderen Packages programmieren kannst aber sowas wirst Du erst mal nicht benötigen.

Auf dem Entwicklungsboard kannst Du natürlich bereits Dein Programm testen, es ist ja nicht nur ein Programmieradapter. Hierfür sind DIP-Schalter und Status-LEDs vorhanden, die Port-PINs des AVR sind an Pfostenleisten abgreifbar, da könntest Du die Siebensegmentanzeigen anschließen.

Atmega8515:
Wieso will der Händler mit dem großen "C" 9€ für einen haben, und der Händler mit dem großen "R" bloss 2,50€ ?
Oder habe ich falsch geschaut, dass es unterschiedliche Typen sind?

Wahrscheinlich weil es genug Kaufwillige gibt, die den auch für 9Euro kaufen. Es gibt zwar unterschiedliche Typen des ATmega8515, aber die kosten in etwa gleich viel. Die Preise schwanken dann besonders, wenn die Nachfrage am Markt groß und das Angebot niedrig ist. Zur Zeit ist zwar wieder Allokation bei elektronischen Bauelementen, aber ich glaube nicht so sehr bei den AVRs.

Ob 8 oder 16Mhz macht nicht wirklich was aus

ATmega8515L ist für niedrigere Betriebsspannungen (2,7V bis 5,5V) und läßt sich bis 8MHz betreiben. Der ATmega8515 arbeitet bei einer Betriebspannung von 4,5V bis 5,5V bis zu 16MHz. Nimm den "normalen" 16MHz -Typ (ohne L).

Der Takt: muss ich dem 8515 eine Frequenz zuführen, oder macht der auch ohne Quarz bzw Quarzoszillator seinen Dienst?

Die AVRs haben einen integrierten R-C-Oszillator (1MHz), so dass sie keinen externen Taktgenerator oder Quarz benötigen. Auf dem STK500 ist aber bestimmt bereits ein Quarz oder ein Crystal-Resonator vorhanden.

Gruss
Dirk

 

[dg2ygq]

So, ich habe nun das STK500 geordert (passt auch für 8515er).
Auch gleich nen paar 8515er sowie ULN2803`s, 5V-Regler und Widerstandsnetzwerke.

Das AVRStudio habe ich mir auch "vorab" besorgt, und es scheint als ob ich (nach einer gewissen (laaaaangen) Zeit) damit was anfangen könnte.
Ich denke dass ich erstmal versuchen werde nen paar LEDs zum "blinken" zu bekommen, bevor ich mich an solche "komplexeren" Dinge begebe.
Noch weiß ich gar nicht wie und wo ich anfangen muss/soll, aber ich frage hier ganz bestimmt schon beim ersten Problem wieder nach!

Nun erst noch mal vielen Dank an Dich, Dirk!

Michael

 

[Dirk]

Hallo Michael,

wenn Dein Board da ist, und Du anfangen willst zu programmieren, kann ich Dir ja mal ein Grundgerüst geben, wie man die Software strukturiert. Wenn man sowas erst einmal hat, dann geht alles weitere wie von selber

Gruss
Dirk

 

[dg2ygq]

Oh ja, ich denke ohne Hilfe werde ich erstmal garnicht klar kommen.
AVR Studio habe ich mir ja nun erstmal vorab installiert, und ich muss sagen dass es schön bunt aussieht *lach*
Aber damit anfangen kann ich noch gar nichts. Mal sehen wann mein BastelSet hier ankommt.
Besten Dank schon mal im Vorraus

Michael

 

[dg2ygq]

Sooo, die Teile sind da ...

Mit AVR-Studio kann ich ohne Einführung noch garnichts anfangen, das WinAVR erscheint mit genau so ungeeignet für einen Unwissenden wie Mich zu sein.

Nun ja, ich irrte einige Stunden planlos in den Proggys rum, und habe nix dazu gelernt :-(

Der C64 ist wohl doch um einiges einfacher gewesen *lach

@Dirk:
Nun mal zum Grundgerüst. Wo fang ich an, was wie und warum ?
Welche Programmiersprache ist für den Anfang am besten geeignet?
Hast du einfache Beispiele für den Anfang, zB über ne Taste ne LED ansteuern (natürlich mit dem AVR dazwischen, ohne bekomm ich nämlich hin *sfg).
Kennst Du vielleicht Seiten oder Bücher die mich beim Enstieg unterstützen?

 

[Dirk]

Hallo Michael,

ich komme leider heute Abend nicht mehr dazu, Dir das Grundgerüst zu erklären und Dir einige Beispiele zu liefern, da ich selbst noch an Software schreiben muss (also auch leider keinen Film heute Abend ). Ich versuche das morgen nachzuholen.

Dirk

 

[dg2ygq]

Supi, würd mich freuen! Ich sitz schon auf heißen Kohlen *lach*
Und im TV verpasst du heute eh nichts

Heute Nacht, um 23:15Uhr, es ist schon dunkel draußen:
Ich glaub zum Anfang wird ne Datei mit Namen "8515def.inc" mit "include" eingefügt, um den Adressen besser verständliche "Namen" zu geben?!
Aber nicht mal das bekomm ich mit dem AVR-Studio hin, HILFEEEEEEEEEEEEEEE *lachhhh*

Ich fürchte Dirk, mit mir wirst du es nicht leicht haben :-S

 

[Dirk]

Ich fürchte Dirk, mit mir wirst du es nicht leicht haben :-S

Gut, ich denke, ich gebe dir erst einmal eine kleine Einführung in AVR Studio 4.


Projekt anlegen

In der Standardeinstellung startet der Project Wizard vom AVR Studio automatich, man kann ihn aber auch im Menü Project aufrufen.

Wenn Du bereits Projekte definiert hast, kannst du diese hier auswählen. Wenn Du ein neues Projekt erstellen möchtest, gehst du folgendermaßen vor.

Button New Project drücken. Danach Atmel AVR Assembler auswählen, einen Projektnamen wählen und den Pfad (Location) deines Projektes auswählen.

Wenn du create initial file angeklickt läßt, wird ein Initial file mit dem Namen des Projektes erzeugt. Das Initial file kannst du umbenennen, wenn du möchtest.

Möchtest Du das Programm nicht mit einem Debugger debuggen, kannst jetzt auf Finish drücken. Wenn Du das Programm mit einem Debugger (Software oder Hardware) debuggen möchtest, drückst du auf Next und wählst dann die Debug Platform aus. Wähle dann hier zum Beispiel AVR Simulator und dann den Mikrocontroller. Danach auf Finish drücken.


Fenster-Übersicht

Links siehst du das Projektfenster. Bei Source Files ist ein Eintrag vorhanden, dies ist dein Initial File, dieses ist übrigens mit einem roten Pfeil gekennzeichnet. Wenn du später einmal mehrere Files in deinem Projekt hast, die du in deinem Initial file mit .include "Beispiel.asm" einbindest, kannst Du das Initial file so erkennen.

Drückst du auf diese Einträge mit einem Doppelklick, dann öffnet sich das entsprechende Edit-Fenster, wo dir der Assemblercode angezeigt wird.

In der Mitte siehst du die Edit-Fenster, bzw. im Moment nur das Edit-Fenster des Initial Files. Damit kannst Du erst einmal anfangen.

Rechts siehst Du das Fenster I/O View, das kannst Du vorerst ignorieren oder ausschalten.

In dem unteren Fenster Build, wird dir angezeigt, ob es beim Assemblieren des Programms Fehler gegeben hat. Hier kann man auf die Fehler klicken, dann wird automatisch im Editor zu der Stelle gesprungen, wo der Fehler aufgetreten ist.
Tipp: Wenn Fehler aufgetreten sind, immer vom oberen Fehler anfangen und wenn du den beseitigt hast, dann erst neu assemblieren, nicht in der Mitte oder unten anfangen.

Wenn Du assemblieren möchtest, dann kannst Du entweder im Menu Build den Menüpunkt Build oder F7 drücken. Tritt beim Assemblieren kein Fehler auf, wird ein Hex-File erzeugt Beispiel.hex, hier ist dein fertiges Programm, was später programmiert wird.


Das erste Programm

An deiner Stelle würde ich erst einmal ein kleines Programm schreiben, was dir zum Beispiel eine LED auf dem Entwicklungsboard blinken läßt. Ich kann dir da ein kleines Beispiel posten, was das macht. Ich kenne jetzt nur dein Entwicklungsboard nicht, und weiß somit nicht, an welchen Portpins LEDs angeschlossen sind, das müsstest du dann entsprechend im Programm ändern oder anpassen.
Was interessant wäre, das ist der Schaltplan des Boards, dann kann ich nämlich die Initialisierung der Ports des Mikrocontrollers bereits im Beispielprogramm erstellen. Der Schaltplan ist bestimmt als PDF-Dokument beim Entwicklungsboard dabei, könntest du mir das mal mailen.

Ein Beispielprogramm bekommst du heute Abend, da ich leider keine Zeit mehr habe, dir das Programm jetzt zu schreiben, ich hoffe, du kannst es noch aushalten, bis die erste LED blinkt

Bis dann,
Dirk

 

[dg2ygq]

Wenn ich das richtig sehe, ist Port B mit den LEDs verbunden. (Unterlagen dazu werde ich "später" mal hoch laden).

Die aller erste Fehlermedung gibt mir AVR-Studio schon bei der "8515def.inc":
C:\8515def.inc(293): error: Attempt to redefine keyword 'or'
Könnte sich um einen Fehler in der Datei handeln ???

Das Fenster "I/O View" könnte mir doch zB auch grafisch den "Zustand" der einzelnen Ports anzeigen, oder liege ich da falsch?

Dass ich erstmal eine LED zum blinken bekomme, würde mir schon einen guten Einblick liefern, hoffe ich zumindest.
Interessant wäre dann als weiterer Schritt, die 8LEDs nach Bitmustern welche irgendwo im Speicher abgelegt sind, an zusteuern...
Aber mal erst ganz langsam und Schritt für Schritt

Mit größter Mühe und Not werde ich versuchen bis heute Abend durch zuhalten

Zusatz:
Ich hab nen bischen getestet :

.INCLUDE "C:\8515def1.inc"
.DEF wert = R16
ldi wert,0b11111111
out DDRB,wert

... In der Hoffnung, alle Bits von Port B auf 1 zu legen.

Wenn ich nun Strg +F7 drücke, bleibt der Pfeil bei der ldi-Zeile stehem, und geht garnicht weiter ???

(8515def1.inc habe ich geändert, da die Originaldatei einen Fehler mit "or" ausgabt (.equ or =3 , geändert in ".equ ort =3) s.o.)

 

[Dirk]

Die Definitionsdatei, die du verwendest ist anscheinend wirklich fehlerhaft. Das "or" darf nicht für .def oder .equ oder als Adresse (Label) verwendet werden, da es für den InstructionCode or (oder) steht.

Verwende folgendes Definitionsfile:
Including 'C:\Programme\Atmel\AVR Tools\AvrAssembler\Appnotes\m8515def.inc'
(im Source m8515def.inc angeben, AVR Studio findes es automatisch)

Ich habe mal ein kleines Programm geschrieben, was du als Grundmuster für deine Programme verwenden kannst.

Kopiere einfach das Programm mit copy/paste in das Editorfenster des Initial files, speicher und drücke F7. Unten siehst du dann, ob das Programm fehlerfrei assembliert wurde.

Du solltest noch die Initialisierung der Ports anpassen, ich habe alle Ports auf Input mit Pullup eingestellt, außer den PortB, der steht auf Output und High. Du hattest ja geschrieben, dass an PortB die LEDs angeschlossen sind. Wenn die LEDs mit K an die Portpins angeschlossen sind, dann sind sie beim Start des Programms alle aus, da alle Portpins von PortB das Potential 5V haben.

Das Programm habe ich im Source kurz kommentiert. Es macht folgendes:

• Initialisiert StackPointer
• Initialisiert Ports
• geht in eine Endlosschleife, in der die LED am PB0 des PortB an- und ausgeschaltet wird. Periodendauer ist 400ms.

Hier das Programm, es befindet sich zusätzlich im Anhang. (habe hier im Forum noch kein Syntax-Highlighting eingebaut, dadurch ist der Sourcecode leider nicht so schön lesbar)

;*********************************************************************************
;*  Programmbeispiel
;*
;*********************************************************************************


.include "m8515def.inc"



;*********************************************************************************
;* Interrupt Vectors ATmega8515                                                  *
;*********************************************************************************

.org 0   ;*** Reset ***
   rjmp SystemInit    
.org 1   ;*** Extern0 Interrupt ***
   reti  
.org 2   ;*** Extern1 Interrupt ***
   reti        
.org 3   ;*** Timer1 Capture Interrupt ***
   reti       
.org 4   ;*** Timer1 CompareA Interrupt ***
   reti
.org 5   ;*** Timer1 CompareB Interrupt ***
   reti
.org 6   ;*** Timer1 Overflow Interrupt ***
   reti
.org 7   ;*** Timer0 Overflow Interrupt ***
   reti
.org 8   ;*** Serial Transfer Complete ***
   reti
.org 9   ;*** UART Receive Complete Interrupt ***
   reti
.org 10  ;*** UDR Empty Interrupt ***
   reti
.org 11  ;*** UART Transmit Complete Interrupt ***
   reti
.org 12  ;*** Analog Comparator Interrupt ***
   reti




;*********************************************************************************
;* Register Definitions                                                          *
;*********************************************************************************

; Hier kannst du eigene Registernamen definieren.
; Die Namen sind Beispiele

.def Reg0         = r0       ; needs for special operations
.def Reg1         = r1       ; needs for special operations
.def Reg2         = r2       ;
.def Reg3         = r3       ; 
.def Reg4         = r4       ; 
.def Reg5         = r5       ;
.def Reg6         = r6       ;
.def Reg7         = r7       ;
.def Reg8         = r8       ; 
.def Reg9         = r9       ;
.def Reg10        = r10      ; 
.def Reg11        = r11      ;
.def Reg12        = r12      ;
.def Reg13        = r13      ;
.def Reg14        = r14      ;
.def Reg15        = r15      ;

; Adressing limit address 16 ! 

.def Flags1       = r16      ; 
   .equ F1_Bit0        = 0   ;
   .equ F1_Bit1        = 1   ;
   ; und so weiter

.def Flags2       = r17      ; 
.def Flags3       = r18      ; 
   
.def RegA         = r19      ;     
.def RegB         = r20      ;                        
.def RegC         = r21      ;      
.def RegD         = r22      ;      
.def RegE         = r23      ;
.def RegF         = r24      ;
.def RegG         = r25      ;

.def RegXL        = r26      ; XL     
.def RegXH        = r27      ; XH   
.def RegYL        = r28      ; YL 
.def RegYH        = r29      ; YH
.def RegZL        = r30      ; ZL
.def RegZH        = r31      ; ZH
 




;*********************************************************************************
;* Internal Registers (DataSegment)                                              *
;*********************************************************************************
.dseg

ExtendedIO:  .byte 160


Variable1:   .byte 1


;*** Code - Segment ***
.cseg


;*********************************************************************************
;* Initialize System                                                             *
;*********************************************************************************

; System Init ist bezüglich der Adresse im Flash direkt hinter den Sprungadressen
; der Interruptvektoren.

SystemInit:


   ;************************************************
   ;*** Watchdog Timer *****************************
   wdr                      ; Watchdog-Timer reset
   ldi RegA, 0b00001101 ; fwd = 1MHz/512k, t=0,5s WatchDog start
   ;out WDTCR, RegA     ; Watchdog erst mal ausgeschaltet.

   ;************************************************
   ;*** Stack Pointer ******************************
   ldi RegA, low(RAMEND) ; StackPointer initialisieren
   out SPL, RegA
   ldi RegA, high(RAMEND)
   out SPH, RegA
                
   ;************************************************
   ;*** Hier noch allg. Funktionen *****************
   rcall InitPorts          ; Ports initialisieren
   rcall InitRegisters      ; Register initialisieren


   ; sonstige initialisieren

   ; jetzt gehts weiter mir Mainloop

;*********************************************************************************
;* MainLoop                                                                      *
;*********************************************************************************




Mainloop:

   wdr


   sbi PORTB, PB0    ; Pin0 vom PortB high
   
   rcall Pause100ms
   rcall Pause100ms

   cbi PORTB, PB0    ; Pin0 vom PortB low

   rcall Pause100ms
   rcall Pause100ms

 

rjmp mainloop    ; zurück



Codebeispiele:


   ;************************************************
   ;*** Beispiele die Ports betreffen **************

   ; Ein PortPin high setzen
   sbi PortA, PA0

   ; Ein PortPin low setzen
   cbi PortA, PA0

   ; kann man auch so machen, PA0 auf high
   in RegA, PortA
   ori RegA, 0b00000001
   out PortA, RegA

   ; oder so, PA0 auf low
   in RegA, PortA
   andi RegA, 0b11111110
   out PortA, RegA

   ; springe über den nächsten Befehl, wenn PIN0 des PortA high ist
   sbis PINA, PA0

   ; springe über den nächsten Befehl, wenn PIN0 des PortA low ist
   sbic PINA, PA0

   ; Inhalt von RegA ins Portregister
   ldi RegA, 0b01010101
   out PORTA, RegA


   ;************************************************
   ;*** Beispiele die Register betreffen ***********

   ; Bit4 in Register RegA setzen
   sbr RegA, 1<<4

   ; Bit 4 und Bit 6 in Register RegA setzen
   sbr RegA, (1<<4) | (1<<6)

   ; Bis löschen
   cbr RegA, 1<<4

   ; 120 ins Register RegA schreiben
   ldi RegA, 120

   ; 0 in RegA schreiben (löschen)
   clr RegA

   ; springe über den nächsten Befehl, wenn Bit4 in RegA gesetzt ist.
   sbrs RegA, 4

   ; springe über den nächsten Befehl, wenn Bit4 in RegA gelöscht ist.
   sbrc RegA, 4


   ;************************************************
   ;*** Beispiele die SRAM Speicher betreffen ******

   ; 55 in Variable1
   ldi RegA, 55
   sts Variable1, RegA

   ; Variable1 in RegA
   lds RegA, Variable1


ret


;***********************************************************************************
;*  Port Definition ATmega8515                                                              
;*
;*  PORTA      7        6        5        4        3        2        1        0
;*  ================================================================================
;*  Name        
;*  --------------------------------------------------------------------------------
;*  Direction  IN       IN       IN       IN       IN       IN       IN       IN
;*  PU/TRI     PU       PU       PU       PU       PU       PU       PU       PU
;*  Port       1        1        1        1        1        1        1        1
;*  Dir        0        0        0        0        0        0        0        0
;*
;*  PORTB      7        6        5        4        3        2        1        0   
;*  ================================================================================
;*  Name       LED7     LED6     LED5     LED4     LED3     LED2     LED1     LED0
;*  --------------------------------------------------------------------------------
;*  Direction  OUT      OUT      OUT      OUT      OUT      OUT      OUT      OUT
;*  PU/TRI     HI       HI       HI       HI       HI       HI       HI       HI
;*  Port       1        1        1        1        1        1        1        1
;*  Dir        1        1        1        1        1        1        1        1
;*
;*  PORTC      7        6        5        4        3        2        1        0
;*  ================================================================================
;*  Name      
;*  --------------------------------------------------------------------------------
;*  Direction  IN       IN       IN       IN       IN       IN       IN       IN
;*  PU/TRI     PU       PU       PU       PU       PU       PU       PU       PU
;*  Port       1        1        1        1        1        1        1        1
;*  Dir        0        0        0        0        0        0        0        0
;*
;*  PORTD      7        6        5        4        3        2        1        0
;*  ================================================================================
;*  Name     
;*  --------------------------------------------------------------------------------
;*  Direction  IN       IN       IN       IN       IN       IN       IN       IN
;*  PU/TRI     PU       PU       PU       PU       PU       PU       PU       PU
;*  Port       1        1        1        1        1        1        1        1
;*  Dir        0        0        0        0        0        0        0        0
;*
;*  PORTE      7        6        5        4        3        2        1        0
;*  ================================================================================
;*  Name       -        -        -        -        -        BL_ON    TXD      RXD
;*  --------------------------------------------------------------------------------
;*  Direction  IN       IN       IN       IN       IN       IN       IN       IN
;*  PU/TRI     PU       PU       PU       PU       PU       PU       PU       PU
;*  Port       1        1        1        1        1        1        1        1
;*  Dir        0        0        0        0        0        0        0        0
;*

;*  
;*  PORT = 1 , Dir = 1 -> Output, High
;*  PORT = 1 , Dir = 0 -> Input, PullUp
;*  PORT = 0 , Dir = 1 -> Output, Low
;*  PORT = 0 , Dir = 0 -> Input, TRIState
;*
;*  DDRx  = Data Direction Register
;*  PORTx = Port Register
;*  PINx  = Pin Register
;*
;***********************************************************************************



InitPorts:


   ldi RegA, 0b11111111   ; Initialize PortA
   out PORTA, RegA
   ldi RegA, 0b00000000
   out DDRA, RegA

   ldi RegA, 0b11111111   ; Initialize PortB
   out PORTB, RegA
   ldi RegA, 0b11111111
   out DDRB, RegA

   ldi RegA, 0b11111111   ; Initialize PortC
   out PORTC, RegA
   ldi RegA, 0b00000000
   out DDRC, RegA

   ldi RegA, 0b11111111   ; Initialize PortD
   out PORTD, RegA
   ldi RegA, 0b00000000 
   out DDRD, RegA

   ldi RegA, 0b11111111   ; Initialize PortE (PE0, PE1, PE2)
   out PORTE, RegA
   ldi RegA, 0b00000000
   out DDRE, RegA


ret


InitRegisters:


   ; irgendetwas initialisieren


ret



; Für die Pause 16MHz Systemtakt verwenden

Pause100ms:
   wdr                            ; Watchdog-Timer reset
   
   ldi RegA, 175
pause100_loop1: ldi RegB, 200 ; Schleife 3 : t3= (3+t2)*TempReg1
pause100_loop2: ldi RegC, 10  ; Schleife 2 : t2=(3+t1)*TempReg2
pause100_loop3: dec RegC      ; Schleife 1 : t1=2*TempReg1
   brne pause100_loop3 
   dec RegB           
   brne pause100_loop2            ; t3 = (3+(3+2*TempReg1)*TempReg2)*TempReg1
   wdr                            ; Watchdog-Timer reset unberuecksichtigt,
                                  ; kann hier jedoch vernachlaessigt werden!!!
   dec RegA                    
   brne pause100_loop1                
ret 

;***********************************************************************************
;*  Include - Dateien
;***********************************************************************************

; Wenn sein Programm mal größer wird, kannst du hier zum Beispiel Include-Dateien
; einbinden, in denen du Teile deines Programms ausgelagert hast. Dann wird alles
; übersichtlicher. ".include" kannst du überall im Code-Segment (".cseg")verwenden.


; .include "irgendwas.asm"

 

[dg2ygq]

Wahnsinn Dirk, das kann nicht in einer 4tel Stunde entstanden sein
Super Beispiel und Klasse Kommentare dabei! Ich werde mich damit erstmal beschäftigen, und soweit versuchen das alles zu verstehen!
Auf den Ersten Blick muss ich sagen, dass es schon verdammt viel code ist, nur um ne LED zum Blinken zu bekommen *grins*

Vielen Dank nochmal, und erstmal eine schönes Wochenende Dir ))

 

[dg2ygq]

So, weiter geht`s ...

Ich glaube ich habe es verstanden wie ich die .hex-datei auf den AVR bekomme.
Allerdings passiert nichts weiter, als dass nur eine LED (PB1) dauernd leuchtet.
Wo muss ich das Programm überhaupt hin schreiben? Flash oder EEPROM? Oder beides?
Gibt es noch Einstellungen die ich falsch haben könnte (Sind ja genug Häkchen da, die ich falsch setzen könnte*sfg)

 

[Dirk]

Hallo Michael.

Wo muss ich das Programm überhaupt hin schreiben? Flash oder EEPROM? Oder beides?

Das Programm muss in den Flash-Speicher. Im Dialog der Programmiersoftware wählst du bei Flash das Hex-File aus, bei EEPROM brauchst du nichts auswählen (ein EEPROM-File wird nur erzeugt, wenn du im Programm in der Section .eseg zum Beispiel mit .db 0x00 Daten definierst, alles was in der Section .cseg ist, gehört in den Flashspeicher).

Wurde denn das Programm richtig programmiert, oder gab es eine Fehlermeldung (ich glaube bei einem Fehler blinkt eine rote LED auf dem Board, bin mir aber nicht so sicher, da ich mit dem STK500 selber noch nicht gearbeitet habe).

Wähle die Programmierart ISP.

Wenn du den ATmega8515 über ISP programmierst, musst du die Stiftleiste ISP6PIN mit SPROG3 verbinden (siehe unteres mittleres Bild und Dokumentation 3.7.1 ISP Programming)

Fusebits auf Standard lassen, ausser Fusebits für den Oszillator, da müsste ExtClock gewählt werden (zB. 6CK+64ms), da dein Mikrocontroller vom ProgrammierMC mit Takt versorgt wird. Nimmst Du einen 16MHz Quarz, dann stellst du Ext Crystal/Resonator high freq. ein. Hier musst du aber auf dem Board entsprechende Jumper setzen. Wichtig wäre noch, dass ISP hier aktiviert bleibt, ich glaube aber das kann man nicht mehr ausschalten.

LockBits unberücksichtigt lassen, nicht programmieren.

Oszillatorfrequenz und Programmierfrequenz:
Wichtig ist die Taktversorgung des Mikrocontrollers. In der Standardeinstellung wird der Mikrocontroller glaube mit einem Takt von dem kleinen MC versorgt, der den Ziel-MC programmiert (bis 3,68MHz). Diese Frequenz müsstest du im Dialog der Programmiersoftware bei Board / STK500-Osc. einstellen können, die ISP-Frequenz stellst du dann auf höchstens 25% der Osc-Frequenz.

LEDs an den richtigen Port anschließen (siehe angehängtes Bild, was allerdings nur ein Beispiel ist, also nicht exakt danach richten). Für LEDs und Taster sind die 10poligen Kabel.

Mein Softwarebeispiel konnte ich nicht austesten, denke aber dass es läuft (hier LEDs an PortB). Wenn du eine kleinere Oszillatorfrequenz verwendest, also zB. 3,68MHz, ist die Blinkfrequenz der LED entsprechend niedriger, da ich die Pause100ms Funktion für 16MHz berechnet habe.

 

[dg2ygq]

Hallo Dirk!

Kompliment, du gibst dir wirklich aller größte Mühe! Alle Achtung!

Ich habe mich an deine Anleitung gehalten, und nun blinkt die LED an PB0!
Was jetzt genau falsch war, weiß ich nicht. Ich hatte schon mal ein wenig in den Einstellungen rum geklickt, vielleicht hatte ich was falsches geklickt?!
Jedenfalls nach Neuinstallation vom AVR_Studio und nach deiner Anleitung läuft es auf Anhieb!

Tja, nun werde ich mich mal ein wenig in die Programmierung knien ....
Kennst da da vielleicht eine gute (deutschsprachige) Seite? Oder gut verständliche Bücher darüber?
Ich möchte ja nun nicht dieses Forum alleine mit meinen Anfängereien dicht machen

Mit ".db" und "0x00" kann ich nun auch noch gar nichts anfangen, genauso ist es bestimmt noch uninteressant wann welche Daten ins EEPROM geschrieben werden. Ich sollte doch besser erst mal ganz unten an fangen, wie beim C64:
10 Print "Hallo"
20 goto 10


Danke schön nochmal.
Michael ...

 

[Dirk]

Hallo Michael!

Tja, nun werde ich mich mal ein wenig in die Programmierung knien ....
Kennst da da vielleicht eine gute (deutschsprachige) Seite? Oder gut verständliche Bücher darüber?

Es gibt relativ viele Bücher, die sich mit der Programmierung der AVRs beschäftigen, die meisten sind mehr oder weniger Übersetzungen der originalen Datenblätter von Atmel. Ich kann dir folgende Bücher empfehlen:

Mikrocomputertechnik mit Controllern der Atmel AVR-RISC-Familie
(Taschenbuch) von Günter Schmitt

AVR-RISC Mikrocontroller, m. CD-ROM (Gebundene Ausgabe)
von Wolfgang Trampert

AVR Mikrocontroller Lehrbuch
von Roland Walter


Deutschsprachige Seiten gibt es nicht so viele, empfehlen kann ich dir zwei Foren, die sich unter anderem auch mit AVR beschäftigen:

www.roboternetz.de (deuschsprachiges Forum)

www.mikrocontroller.net (deuschsprachiges Forum)


Ich möchte noch eine englischsprachige Seite erwähnen:

www.avrfreaks.net (englischsprachiges Forum)


Speziell zum Thema Assembler:

AVR Assembler-Tutorial

Ich möchte ja nun nicht dieses Forum alleine mit meinen Anfängereien dicht machen

Also "dicht machen" wirst du nicht schaffen Ausserdem lebt das Forum von den Usern, nicht von mir. Kannst also ruhig wieder mal fragen, wenn du Probleme hast oder irgendwie nicht weiterkommst.

Grüße,
Dirk