Heute abend hab ich wieder Linux unter der Tastatur, da kann ich dir dann nochmal helfen ;)
Druckbare Version
Heute abend hab ich wieder Linux unter der Tastatur, da kann ich dir dann nochmal helfen ;)
Danke Georg !,
da bin ich wieder bestimmt online...eine Fehler habe ich gefunden...Ich habe immer die Led.c geändert , das Makefile ist aber auf main.c ausgelegt.. Na ja aus Fehlern lernt man. Ich muss mich da mit Make und Makefile noch befassen...habe leider in meiner Fachöliteratur bislang nix darüber gefunden...habe diesen Werdegang auch noch nire gebraucht, aber doch schon mal was davon gehört.
In meiner Informatikerausbildung haben wir das so auch nicht gebraucht, war nur in Richtung Windoof gewesen mit MS C++.
Gerhard
Nachtrag mit dieser Änderung des Makefiles geht der AVRISP auch:
Zitat:
CC=avr-gcc
RM=rm -f
OBJCOPY=avr-objcopy
# Für USB-ASP Programmer
#AVRDUDE=sudo avrdude -p m1284p -c usbasp -P usb -e -U flash:w:
# Für AVRISP Progger(neu) Manufacturer: ERFOS
AVRDUDE=sudo avrdude -p m1284p -c avrispmkII -P /dev/ttyACM0 -e -U flash:w:
AVRSIZE=avr-size
MCU=atmega1284p
F_CPU=16000000
CFLAGS=-g -DF_CPU=$(F_CPU) -Wall -Os -mcall-prologues
OBJ = main.o
BIN = blink.bin
HEX = blink.hex
MAP = blink.map
.phony: all
all: $(OBJ)
$(RM) $(HEX) $(BIN) $(MAP)
$(CC) -mmcu=$(MCU) $(CFLAGS) -o $(BIN) -Wl,-Map,$(MAP) $(OBJ)
$(OBJCOPY) -R .eeprom -O ihex $(BIN) $(HEX)
%.o: %.c
$(CC) -mmcu=$(MCU) $(CFLAGS) -c $<
clean:
$(RM) $(OBJ) $(BIN) $(HEX) $(MAP)
flash: $(OBJ)
$(AVRDUDE)$(HEX)
size: $(BIN)
$(AVRSIZE) -C --mcu=$(MCU) $(BIN)
Dann bringst du ja dein hex File in den Avr ein. Sehr gut :)
Sprich nur noch die Fuse bits, welche wie folgt erledigt werden:
aus dem vusb Makefile entliehene Beschreibung der Bits.Code:# Fuse high byte:
# 0x5f = 0 1 0 1 1 1 1 1 <-- BODLEVEL0 (Brown out trigger level bit 0)
# ^ ^ ^ ^ ^ ^ ^------ BODLEVEL1 (Brown out trigger level bit 1)
# | | | | | +-------- BODLEVEL2 (Brown out trigger level bit 2)
# | | | | + --------- EESAVE (don't preserve EEPROM over chip erase)
# | | | +-------------- WDTON (WDT not always on)
# | | +---------------- SPIEN (allow serial programming)
# | +------------------ DWEN (ebug wire is enabled)
# +-------------------- RSTDISBL (reset pin is disabled)
# Fuse low byte:
# 0xdf = 1 1 0 1 1 1 1 1
# ^ ^ \ / \--+--/
# | | | +------- CKSEL 3..0 (external >8M crystal)
# | | +--------------- SUT 1..0 (crystal osc, BOD enabled)
# | +------------------ CKOUT (clock output enable)
# +-------------------- CKDIV8 (divide clock by eight disabled)
AVRDUDE=sudo avrdude -P deineschnittstelle -c deinprogger -p deintarget -U lfuse:w:0xdf:m -U hfuse:w:0x5f:m -U flash:w:
Die Low/High Fusebits anpassen. WICHTIG!!!
Gruß
Georg
Danke Georg !
Ja so allmälich klapps auch unter Linux....Ist schon eine Umstellung wenn man sonst nur unter AVR Studio oder manchmal Bascom programmiert/geflasht hat.
Darum hatte/habe ich auch so viele Programmer, weil das eine mit dem und das andere mit dem nur ging. bestimmt gehen auchj alle, nur bin ich wohl nicht gut genug um alle anzupassen für die entsprechende Software.
Ich denke das ich mich über den kommenden Winter in Linux wieder einarbeiten werden, noch ist mir das Ubuntu12 etwas ungewohnt in der Bedieneroberfläche, war schon mal einfacher. Ich bin ja mit RedHat/Fedora "linuxtauglich" geworden. In den 90ern war ich auch noch bei einer Linuxgroup an einer FH, aber nun ist es für mich schon zu umständlich daran teilzunehmen geworden, vom Anfahrweg her...
Wenn ich mich mit "Geany" besser eingearbeitet habe wird dann auch einiges leichter für mich in Sachen AVR unter Linux. da muss ich die Einstellungen für Avrdue herrausfinden, einstellen usw...
Na trotzdem bin ich jetzt schon froh, dass ich doch auch schon etwas unter Linux programmieren kann.
Gruss und Dank
Gerhard
Ich mag Geany, da man damit einfach eigene Commandos ins Menü einfügen kann. Bsp, Flashen ;)
Gruß
Georg
Mit dem Burn-o-mat (auf deutsch) kannst du die Fuses über eine GUI programmieren bzw. den entsprechenden avrdude-befehl kopieren, ist vermutlich leichter als alles am Anfang direkt zu machen.
@Chysylon
Danke !
Werde mir das später anschauen installieren...
@Georg
Bestimmt kann ich Dich auch in Sachen Geany befragen ? ;) Heute kam mein 80x5x/AT89x5x Enwicklerboard aus Fernost an...Nun suche ich erst mal da nach ner Möglichkeit ein erstes Testprogramm drauf zu brennnen....muss sehen ob es geht.
Nicht ATmel bietet da was an Software an..oder nur uralt noch mit Lpt Port Verwendung.
Ich weiss ja nicht ob es einem ISP-Progger egal ist was als ISP Ziel drann hängt...jedenfalls noch keinen Erfolg...muss mal googlen.. :(
Gerhard
Also um noch den Zusammenhang: Geany <-> Compiler <-> Makefile usw. zu verdeutlichen:Zitat:
Zitat von oderlachs
Du musst ja das Programm irgendwie auf den AVR bekommen. Dafür gibt es ein Programm namens "avrdude". Wenn du jetzt z.B. ein anderes Programmiergerät hast, muss avrdude mit anderen Parametern aufgerufen werden.
Du musst das Programm in Maschinensprache übersetzen, damit du es überhaupt übertragen kannst. Dafür gibt es den "gcc-avr" (die C-Bibliothek avr-libc gehört da auch dazu).
Mit diesen beiden Tools kannst du also Theoretisch schon AVRs programmieren: Du machst dir eine Datei namens "main.c" und schreibst da den Quellcode rein. Dann könntest du dir ein Terminal aufmachen (Strg + Alt + t), in deinen Projektordner wechseln (cd pfad/zum/ordner) und dort als erstes das Programm übersetzen, z.B.:
dann linkenCode:avr-gcc -g -Os -mmcu=<mcu type> -c file_name.c
und dann noch ein hex-file daraus machen, damit man es flashen kann:Code:avr-gcc -g -mmcu=<mcu type> -o file_name.elf file_name.o
Dann das hex-file noch Flashen:Code:avr-objcopy -j .text -j .data -O ihex file_name.elf file_name.hex
Allerdings ist das alles sehr umständlich und macht keinen Spaß. Aus diesem Grund gibt es makefiles: man kann es aufrufen und ihm sagen, was es machen soll (z.B. "all", "flash", "program"), und das makefile führt dann die oben genannten Programme aus. Inzwischen gibt es viele verschiedene makefiles, und jedes funktioniert ein bisschen anders..Code:avrdude -p <mcu_type> -P <port> -c <programming_device> -U flash:w:file_name.hex
Wenn du jetzt so ein makefile in deinem Projektordner hast, brauchst du nur noch im Terminal in deinen Projektordner gehen (cd pfad/zum/ordner) und dort, je nach dem was du machen willst, folgende Befehle ausführen:
Das ist doch schon mal viel besser, als die vielen kryptischen Befehle oben :)
makefile im Ubuntuusers-Wiki:
makefile von Schorsch_76:
Übersetzen:
make all make all Programmieren:
make program make flash Aufräumen:
make clean make clean
Damit das funktioniert, muss das Makefile allerdings noch richtig konfiguriert werden: Wenn man sich die Befehle oben ansieht, merkt man, dass man Informationen wie den verwendeten Controller, Programmiergerät usw. angeben muss. Diese Informationen braucht das Makefile natürlich auch, damit es die obigen Befehle ausführen kann. Und deshalb müssen diese Informationen in das Makefile eingetragen werden.
Im Falle des Makefiles von Schorsch ist das dieser Bereich:
Die roten Dinge musst du also anpassen. Bei dem Makefile im Ubuntuusers-Wiki ist das:Code:AVRDUDE=sudo avrdude -p m168 -c avrispmkii -P usb -e -U flash:w:
AVRSIZE=avr-size
MCU=atmega168p
F_CPU=16000000
Die sind zwar leichter anzugeben, dafür etwas etwas verstreuter im Makefile verteilt (genaueres: http://wiki.ubuntuusers.de/avr#Einri...klungsumgebung ).Wenn man jetzt z.B. "make all" ausführt, sieht das makefile nach, welcher Controller etc. eingetragen ist, und führt dann automatisch die oben hingeschrieben Befehle mit den passenden Einstellungen aus.Code:MCU = atmega16
F_OSC = 3686400
AVRDUDE_PROGRAMMER = stk500
AVRDUDE_PORT = usb
Ich hoffe das dir damit die Rolle des makefiles etwas klarer ist, und du gemerkt hast, dass diese beiden Sätze eigentlich nichts miteinander zu tun haben:
Denn das neue Board hat ja ein anderes Programmiergerät, je nach dem welchen du draufsteckst auch einen anderen Controller und auch eine andere Taktfrequenz. Das sind aber alles Dinge, die im Makefile (siehe rote Markierungen oben) einstellen kannst, und die mit Geany in keinem Zusammenhang stehen.Zitat:
Bestimmt kann ich Dich auch in Sachen Geany befragen ? :wink: Heute kam mein 80x5x/AT89x5x Enwicklerboard aus Fernost an...
Die Rolle von Geany folgt jetzt:
Als erstes eignet sich Geany toll zum schreiben von C-Programmen, weil es Syntax-highlighting (Schlüsselwörter farbig darstellen) und noch viele weitere tolle Dinge beherrscht (Autovervollständigung, Suchen & Ersetzen, in mehreren Zeilen gleichzeitig schreiben etc.). Aber dieser Editor hat noch einen enormen Vorteil:
Bis jetzt wäre es ja so, dass du mit Geany deinen Quellcode schreibst (die Einstellungen im Makefile kannst du damit natürlich auch anpassen), aber um dein Programm auf den Controller zu bekommen musst du immer noch:
- Terminal öffnen
- mit "cd pfad/zum/ordner" in deinen Projektordner wechseln
- mit "make all" das Programm in maschinensprache übersetzen
- mit "make program" oder "make flash" (je nach verwendetem makefile) das Programm auf den Controller brennen
Das ist natürlich doof und umständlich, aber hier kommt Geany: Man kann nämlich einzelnen Buttons selbst Befehle zuordnen, die ausgeführt werden, wenn man den Button drückt. Also würe man sich idealerweise einen Button so belegen, dass er "make all" im Projektordner ausführt, und einen anderen, der "make program" bzw. "make flash" ausführt. Und diese Belegung kann man so einstellen: http://wiki.ubuntuusers.de/avr#Einri...klungsumgebung
Jetzt brauchst du eben nur noch die Buttons anklicken, oder alternativ "F8" für "make all" und "F9" für "make program/flash" drücken. Is doch super, oder? :)
Noch eine Sache zum Schluss:
Unter Linux ist die Rechteverteilung sehr streng. Das ist sehr gut für die Sicherheit, und wohl der größte Grund, warum es bisher noch keine ernstzunehmende Schadsoftware gibt. Im Zuge dessen werden dir allerdings auch nicht die Rechte gegeben, um einfach so deine Programmiersoftware zu benutzen.
Das ist auch der Grund für folgende Zeile im Makefile von Schorsch:
Warscheinlich ist dir sudo ja bekannt: Man kann damit Root-Rechte bekommen, und darf mit dem ganzen System alles anstellen. Das ist aus zweierlei Sicht schlecht
- Man muss zum programmieren immer das Passwort eingeben
- das avrdude darf dann alles erdenkliche mit deinem System anstellen. Würde jemand Schadsoftware ist avrdude hineinprogrammieren, könnte das Programm deinen Computer zerlegen (könnte auch durch einen Fehler in der Software passieren)
Es wäre also sinnvoller, dir selbst die Rechte zu geben, mit dem Programmiergerät zu arbeiten (wenn du das Programm aufrufst, darf es alles, was du darfst). Dazu musst du:
- Einen Editor mit Root-Rechten öffnen: "gksudo gedit"
- Eine Neue Datei machen
- Dort folgenden Inhalt hineinkopieren:
Code:# Atmel AVR ISP mkII
SUBSYSTEM=="usb", ATTRS{idVendor}=="03eb", ATTRS{idProduct}=="2104", GROUP="plugdev", MODE="0660"
# usbprog bootloader
ATTRS{idVendor}=="1781", ATTRS{idProduct}=="0c62", GROUP="plugdev", MODE="0660"
# USBasp programmer
ATTRS{idVendor}=="16c0", ATTRS{idProduct}=="05dc", GROUP="plugdev", MODE="0660"
# USBtiny programmer
ATTRS{idVendor}=="1781", ATTRS{idProduct}=="0c9f", GROUP="plugdev", MODE="0660"
- Die Datei unter /etc/udev/rules.d/015_usbprog.rules speichern
- Das Programmiergerät ab- und wieder anstecken, falls es angesteckt war
Ich hoffe dir sind die Zusammenhänge jetzt etwas klarer :)
Viele Grüße
-schumi-
PS: Könntest du noch verraten, welches Entwicklerboard du dir gegönnt hast? Dann könnte ich dir evtl. sagen, was die richtigen Einstellungen für das Makefile sind, und ob das mit den Linux-Rechten so klappt
Hallo Schumi !!
Ein wirklich vom herzen kommendes Dankeschön möchte ich Dir sagen, eine Suuperanleitung für mich, es ist doch schön wenn man hier gute Freunde findet die einem helfen. Das was hier zu meiner Anfrage geschrieben besser geantwortet wurde verdient meinen vollen Respeckt und Hochachtung für Schursch und Dich Schumi, Ihr habt Euch wirklich viel Mühe mit mir gemacht, Danke !
Dieses 8051 DeveloperBoard habe ich mir geleistet, leider hat der verkäufer keine weiteren Unterlagen.
Später etwas mehr , wenn ich besser "Duchblick" habe ;)
Gruss und Dank !!
Gerhard
Biddeschön ;)Zitat:
Zitat von oderlachs
Von der Ebay-Seite:
So wie es aussieht hat das Board also keine eigene Programmierschaltung, sondern nur einen Anschluss zum programmieren (ISP - InSystemProgramming). Dort musst du einen eigenen Programmieradapter anstecken, z.B. UsbAsp.Zitat:
AT-ISP (10pin)download interface
Makefile dafür wäre dann (angenommen du benutzt den ATMEGA8515):
Schorsch:
(das "sudo" vor avrdude habe ich jetzt mal weggelassen, wenn die Rechte passend eingestellt sind braucht man das ja nicht mehr)Code:AVRDUDE=avrdude -p m8515 -c usbasp -P usb -e -U flash:w:
AVRSIZE=avr-size
MCU=atmega8515
F_CPU=1000000
Ubuntuusers-Wiki:
Den Takt habe ich mit 1Mhz angenommmen, da neue AVRs das ja voreingestellt haben. Falls der Quarz schon aktiviert ist, eben 12Mhz eintragen.Code:MCU = atmega8515
F_OSC = 1000000
AVRDUDE_PROGRAMMER = usbasp
AVRDUDE_PORT = usb
Viele Grüße
Simon
<EDIT>
Wegen den Fuses:
Da kann man den AVR-8-Burn-O-Mat benutzen.
- Java installieren. Im Terminal eingeben: "sudo apt-get install default-jre" (Kann sein dass es schon von Haus aus installiert ist, weis ich gerade nicht..)
- Burn-o-mat hier herunterladen: http://avr8-burn-o-mat.aaabbb.de/AVR...-Mat_2_1_2.zip
- Mit Dateimanager in den Downloads-Ordner gehen
- Rechtsklick auf AVR8_Burn...zip und "hier Entpacken" (oder wie auch immer das bei dir dann heißt) wählen
- In den entpackten AVR8_Burn-O-Mat Ordner wechseln
- Leider hat der Autor bei der Datei "start.sh" etwas vergessen: Das Programm lässt sich nur starten, wenn man sich im Augenblick auch im richtigen Ordner befindet. Das macht der Dateimanager aber nicht unbedingt, deswegen musst du in der Datei "start.sh" noch eine Zeile einfügen (Einfach rechtsklick drauf und öffnen mit Gedit oder Geany oder ...):
Die Zeile in der Mitte eintragen, speichern und wieder schließenCode:#!/bin/bash
cd "$( dirname "${BASH_SOURCE[0]}" )"
java -jar AVR8_Burn_O_Mat.jar
- Jetzt musst der Burn-O-Mat gestartet werden. Allerdings muss man erst erlauben, die Datei als Programm auszuführen (auch Sicherheitsfeature: z.B. kann man Schadsoftware die via EMail versendet wird nicht einfach mit draufklicken starten): Rechtsklick auf die Datei "start.sh" -> Eigenschaften. Dort musst du dann beim dritten Reiter die Ausführung als Programm erlauben. Hier gibts ein Bild davon: http://3.bp.blogspot.com/-vyc_rUSU6a...s1600/0028.png Falls das nicht klappt, kannst du auch ein Terminal öffnen und dort hineinkopieren: "chmod +x ~/Downloads/AVR8_Burn-O-Mat/start.sh"
- Jetzt solltest du das Programm mit einem Doppelklick auf "start.sh" starten können. Falls das nicht geht, kannst du auch ein Terminal öffnen und dort hineinkopieren: "~/Downloads/AVR8_Burn-O-Mat/start.sh"
- So, jetzt läuft das Programm, und man muss noch die passenden Einstellungen treffen. Im Menu vom Programm auf "Settings" und dort "AVRDUDE" auswählen. Bei "AVRDUDE location" folgendes eintragen: "/usr/bin/avrdude". Bei "alternative AVRDUDE configuration file" folgendes eintragen: "/etc/avrdude.conf". Dann "Ok" klicken und das Programm schließen. Dann das Programm mit klicken auf "start.sh" wieder starten (erst dann werden die Werte die du eingetragen hast übernommen) und wieder nach "Settings" -> "AVRDUDE" gehen.
- Jetzt musst du noch deinen Programmer auswählen: in dem Kasten unter den beiden Pfaden die du vorher eingetragen hast, gibt es ein Auswahlmenü für "Programmer", dort den richtigen auswählen (z.B. "usbasp"). Dann musst du eins drunter bei "Port" noch auswählen, wie dein Programmer angeschlossen ist. Im Fall von USBasp ist "usb" der richtige Eintrag. Dann mit "OK" bestätigen
- Jetzt kannst du bei "AVR type" z.B. den "ATmega8515" auswählen und dann auf "Fuses" klicken
- Was du immer zuerst unbedingt machen solltest, ist auf "read fuses" zu klicken!!! (Damit werden in dem Konfigurations-Fenster das gerade offen ist die aktuellen Einstellungen übernommen)
- Jetzt kannst du entweder mithilfe der Häckchen die Fuses setzen (Wenn du ein Rot-Markiertes Häckchen setzen willst, musst du erst bei "Mode: normal" auf "Mode: expert" umstellen). Oder du schaust dir noch die anderen Reiter an. Ich finde z.B. den "Oscillator/Clock Options"-Reiter sehr toll. Dort wählt man einfach die Taktquelle und Frequenz die man haben möchte
- Wenn du deine Einstellungen gemacht hast, klickst du auf "write fuses"
- Am besten klickt man direkt danach noch mal auf "read fuses", um sicher zu gehen, dass man immer noch mit dem AVR kommunizieren kann. (und nicht z.B. den Takt auf "external RC-Oscillator" gestellt hat, obwohl man garkeinen angeschlossen hat, und sich der AVR mangels Taktversorgung somit nicht mehr programmieren lässt)
Wie du sehen kannst, ist es also leider nicht ganz einfach das Programm zum laufen zu bekommen, aber es lohnt sich doch :)