-         

Seite 1 von 3 123 LetzteLetzte
Ergebnis 1 bis 10 von 27

Thema: RN-Control 1.4: Hex erstellen für Übertragung per RS232

  1. #1
    Neuer Benutzer Öfters hier
    Registriert seit
    19.10.2007
    Alter
    29
    Beiträge
    27

    RN-Control 1.4: Hex erstellen für Übertragung per RS232

    Anzeige

    Hallo wiedereinmal

    Gestern habe ich mein RN-Control bekommen. Auf den ersten Blick macht es auch schon ein super Eindruck. Leider bin ich bereits auf ein Problem gestossen:

    1. Wie erstelle ich aus meinen Beispielprogrammen aus der CD ein HEX-File, um es per RS232 zu übertragen?
    Ich habs bereits mit Programmer's Editor probiert, stehe aber an, welches Makefile ich nehmen muss. Wie kann ich die Datei der beiliegenden CD ("E:\Anleitungen_Projekte und Boards\rn-control\c_beispiel\Makefile" umwandeln, dass sie vom Programm gelesen wird und funktioniert (HEX-File ausgibt)? => Natürlich in C++

    Code:
    # Hey Emacs, this is a -*- makefile -*-
    #
    # WinAVR Sample makefile written by Eric B. Weddington, Jörg Wunsch, et al.
    # Released to the Public Domain
    # Please read the make user manual!
    #
    # Additional material for this makefile was submitted by:
    #  Tim Henigan
    #  Peter Fleury
    #  Reiner Patommel
    #  Sander Pool
    #  Frederik Rouleau
    #  Markus Pfaff
    #
    # On command line:
    #
    # make all = Make software.
    #
    # make clean = Clean out built project files.
    #
    # make coff = Convert ELF to AVR COFF (for use with AVR Studio 3.x or VMLAB).
    #
    # make extcoff = Convert ELF to AVR Extended COFF (for use with AVR Studio
    #                4.07 or greater).
    #
    # make program = Download the hex file to the device, using avrdude.  Please
    #                customize the avrdude settings below first!
    #
    # make filename.s = Just compile filename.c into the assembler code only
    #
    # To rebuild project do "make clean" then "make all".
    #
    
    
    # MCU name
    MCU = atmega32
    
    # Output format. (can be srec, ihex, binary)
    FORMAT = ihex
    
    # Target file name (without extension).
    TARGET = RNControl
    
    
    # List C source files here. (C dependencies are automatically generated.)
    SRC = $(TARGET).c
    
    
    # List Assembler source files here.
    # Make them always end in a capital .S.  Files ending in a lowercase .s
    # will not be considered source files but generated files (assembler
    # output from the compiler), and will be deleted upon "make clean"!
    # Even though the DOS/Win* filesystem matches both .s and .S the same,
    # it will preserve the spelling of the filenames, and GCC itself does
    # care about how the name is spelled on its command-line.
    ASRC = 
    
    
    
    # Optimization level, can be [0, 1, 2, 3, s]. 
    # 0 = turn off optimization. s = optimize for size.
    # (Note: 3 is not always the best optimization level. See avr-libc FAQ.)
    OPT = s
    
    # Debugging format.
    # Native formats for AVR-GCC's -g are stabs [default], or dwarf-2.
    # AVR (extended) COFF requires stabs, plus an avr-objcopy run.
    DEBUG = stabs
    
    # List any extra directories to look for include files here.
    #     Each directory must be seperated by a space.
    EXTRAINCDIRS = 
    
    
    # Compiler flag to set the C Standard level.
    # c89   - "ANSI" C
    # gnu89 - c89 plus GCC extensions
    # c99   - ISO C99 standard (not yet fully implemented)
    # gnu99 - c99 plus GCC extensions
    CSTANDARD = -std=gnu99
    
    # Place -D or -U options here
    CDEFS =
    
    # Place -I options here
    CINCS =
    
    
    # Compiler flags.
    #  -g*:          generate debugging information
    #  -O*:          optimization level
    #  -f...:        tuning, see GCC manual and avr-libc documentation
    #  -Wall...:     warning level
    #  -Wa,...:      tell GCC to pass this to the assembler.
    #    -adhlns...: create assembler listing
    CFLAGS = -g$(DEBUG)
    CFLAGS += $(CDEFS) $(CINCS)
    CFLAGS += -O$(OPT)
    CFLAGS += -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums
    CFLAGS += -Wall -Wstrict-prototypes
    CFLAGS += -Wa,-adhlns=$(<:.c=.lst)
    CFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
    CFLAGS += $(CSTANDARD)
    
    
    
    # Assembler flags.
    #  -Wa,...:   tell GCC to pass this to the assembler.
    #  -ahlms:    create listing
    #  -gstabs:   have the assembler create line number information; note that
    #             for use in COFF files, additional information about filenames
    #             and function names needs to be present in the assembler source
    #             files -- see avr-libc docs [FIXME: not yet described there]
    ASFLAGS = -Wa,-adhlns=$(<:.S=.lst),-gstabs 
    
    
    
    #Additional libraries.
    
    # Minimalistic printf version
    PRINTF_LIB_MIN = -Wl,-u,vfprintf -lprintf_min
    
    # Floating point printf version (requires MATH_LIB = -lm below)
    PRINTF_LIB_FLOAT = -Wl,-u,vfprintf -lprintf_flt
    
    PRINTF_LIB = 
    
    # Minimalistic scanf version
    SCANF_LIB_MIN = -Wl,-u,vfscanf -lscanf_min
    
    # Floating point + %[ scanf version (requires MATH_LIB = -lm below)
    SCANF_LIB_FLOAT = -Wl,-u,vfscanf -lscanf_flt
    
    SCANF_LIB = 
    
    MATH_LIB = -lm
    
    # External memory options
    
    # 64 KB of external RAM, starting after internal RAM (ATmega128!),
    # used for variables (.data/.bss) and heap (malloc()).
    #EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff
    
    # 64 KB of external RAM, starting after internal RAM (ATmega128!),
    # only used for heap (malloc()).
    #EXTMEMOPTS = -Wl,--defsym=__heap_start=0x801100,--defsym=__heap_end=0x80ffff
    
    EXTMEMOPTS =
    
    # Linker flags.
    #  -Wl,...:     tell GCC to pass this to linker.
    #    -Map:      create map file
    #    --cref:    add cross reference to  map file
    LDFLAGS = -Wl,-Map=$(TARGET).map,--cref
    LDFLAGS += $(EXTMEMOPTS)
    LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)
    
    
    
    
    # Programming support using avrdude. Settings and variables.
    
    # Programming hardware: alf AVR910 avrisp Bascom bsd 
    # dt006 pavr picoweb pony-stk200 sp12 stk200 stk500
    #
    # Type: avrdude -c ?
    # to get a full listing.
    #
    AVRDUDE_PROGRAMMER = stk200
    
    # com1 = serial port. Use lpt1 to connect to parallel port.
    AVRDUDE_PORT = lpt1
    
    AVRDUDE_WRITE_FLASH = -U flash:w:$(TARGET).hex
    #AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
    
    
    # Uncomment the following if you want avrdude's erase cycle counter.
    # Note that this counter needs to be initialized first using -Yn,
    # see avrdude manual.
    #AVRDUDE_ERASE_COUNTER = -y
    
    # Uncomment the following if you do /not/ wish a verification to be
    # performed after programming the device.
    #AVRDUDE_NO_VERIFY = -V
    
    # Increase verbosity level.  Please use this when submitting bug
    # reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude> 
    # to submit bug reports.
    #AVRDUDE_VERBOSE = -v -v
    
    AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)
    AVRDUDE_FLAGS += $(AVRDUDE_NO_VERIFY)
    AVRDUDE_FLAGS += $(AVRDUDE_VERBOSE)
    AVRDUDE_FLAGS += $(AVRDUDE_ERASE_COUNTER)
    
    
    
    # ---------------------------------------------------------------------------
    
    # Define directories, if needed.
    DIRAVR = c:/winavr
    DIRAVRBIN = $(DIRAVR)/bin
    DIRAVRUTILS = $(DIRAVR)/utils/bin
    DIRINC = .
    DIRLIB = $(DIRAVR)/avr/lib
    
    
    # Define programs and commands.
    SHELL = sh
    CC = avr-gcc
    OBJCOPY = avr-objcopy
    OBJDUMP = avr-objdump
    SIZE = avr-size
    NM = avr-nm
    AVRDUDE = avrdude
    REMOVE = rm -f
    COPY = cp
    
    
    
    
    # Define Messages
    # English
    MSG_ERRORS_NONE = Errors: none
    MSG_BEGIN = -------- begin --------
    MSG_END = --------  end  --------
    MSG_SIZE_BEFORE = Size before: 
    MSG_SIZE_AFTER = Size after:
    MSG_COFF = Converting to AVR COFF:
    MSG_EXTENDED_COFF = Converting to AVR Extended COFF:
    MSG_FLASH = Creating load file for Flash:
    MSG_EEPROM = Creating load file for EEPROM:
    MSG_EXTENDED_LISTING = Creating Extended Listing:
    MSG_SYMBOL_TABLE = Creating Symbol Table:
    MSG_LINKING = Linking:
    MSG_COMPILING = Compiling:
    MSG_ASSEMBLING = Assembling:
    MSG_CLEANING = Cleaning project:
    
    
    
    
    # Define all object files.
    OBJ = $(SRC:.c=.o) $(ASRC:.S=.o) 
    
    # Define all listing files.
    LST = $(ASRC:.S=.lst) $(SRC:.c=.lst)
    
    
    # Compiler flags to generate dependency files.
    GENDEPFLAGS = -Wp,-M,-MP,-MT,$(*F).o,-MF,.dep/$(@F).d
    
    
    # Combine all necessary flags and optional flags.
    # Add target processor to flags.
    ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)
    ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)
    
    
    
    
    
    # Default target.
    all: begin gccversion sizebefore build sizeafter finished end
    
    build: elf hex eep lss sym extcoff
    
    elf: $(TARGET).elf
    hex: $(TARGET).hex
    eep: $(TARGET).eep
    lss: $(TARGET).lss 
    sym: $(TARGET).sym
    
    
    
    # Eye candy.
    # AVR Studio 3.x does not check make's exit code but relies on
    # the following magic strings to be generated by the compile job.
    begin:
    	@echo
    	@echo $(MSG_BEGIN)
    
    finished:
    	@echo $(MSG_ERRORS_NONE)
    
    end:
    	@echo $(MSG_END)
    	@echo
    
    
    # Display size of file.
    HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex
    ELFSIZE = $(SIZE) -A $(TARGET).elf
    sizebefore:
    	@if [ -f $(TARGET).elf ]; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); echo; fi
    
    sizeafter:
    	@if [ -f $(TARGET).elf ]; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); echo; fi
    
    
    
    # Display compiler version information.
    gccversion : 
    	@$(CC) --version
    
    
    
    # Program the device.  
    program: $(TARGET).hex $(TARGET).eep
    	$(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE_EEPROM)
    
    
    
    
    # Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.
    COFFCONVERT=$(OBJCOPY) --debugging \
    --change-section-address .data-0x800000 \
    --change-section-address .bss-0x800000 \
    --change-section-address .noinit-0x800000 \
    --change-section-address .eeprom-0x810000 
    
    
    coff: $(TARGET).elf
    	@echo
    	@echo $(MSG_COFF) $(TARGET).cof
    	$(COFFCONVERT) -O coff-avr $< $(TARGET).cof
    
    
    extcoff: $(TARGET).elf
    	@echo
    	@echo $(MSG_EXTENDED_COFF) $(TARGET).cof
    	$(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof
    
    
    
    # Create final output files (.hex, .eep) from ELF output file.
    %.hex: %.elf
    	@echo
    	@echo $(MSG_FLASH) $@
    	$(OBJCOPY) -O $(FORMAT) -R .eeprom $< $@
    
    %.eep: %.elf
    	@echo
    	@echo $(MSG_EEPROM) $@
    	-$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \
    	--change-section-lma .eeprom=0 -O $(FORMAT) $< $@
    
    # Create extended listing file from ELF output file.
    %.lss: %.elf
    	@echo
    	@echo $(MSG_EXTENDED_LISTING) $@
    	$(OBJDUMP) -h -S $< > $@
    
    # Create a symbol table from ELF output file.
    %.sym: %.elf
    	@echo
    	@echo $(MSG_SYMBOL_TABLE) $@
    	$(NM) -n $< > $@
    
    
    
    # Link: create ELF output file from object files.
    .SECONDARY : $(TARGET).elf
    .PRECIOUS : $(OBJ)
    %.elf: $(OBJ)
    	@echo
    	@echo $(MSG_LINKING) $@
    	$(CC) $(ALL_CFLAGS) $(OBJ) --output $@ $(LDFLAGS)
    
    
    # Compile: create object files from C source files.
    %.o : %.c
    	@echo
    	@echo $(MSG_COMPILING) $<
    	$(CC) -c $(ALL_CFLAGS) $< -o $@ 
    
    
    # Compile: create assembler files from C source files.
    %.s : %.c
    	$(CC) -S $(ALL_CFLAGS) $< -o $@
    
    
    # Assemble: create object files from assembler source files.
    %.o : %.S
    	@echo
    	@echo $(MSG_ASSEMBLING) $<
    	$(CC) -c $(ALL_ASFLAGS) $< -o $@
    
    
    
    # Target: clean project.
    clean: begin clean_list finished end
    
    clean_list :
    	@echo
    	@echo $(MSG_CLEANING)
    	$(REMOVE) $(TARGET).hex
    	$(REMOVE) $(TARGET).eep
    	$(REMOVE) $(TARGET).obj
    	$(REMOVE) $(TARGET).cof
    	$(REMOVE) $(TARGET).elf
    	$(REMOVE) $(TARGET).map
    	$(REMOVE) $(TARGET).obj
    	$(REMOVE) $(TARGET).a90
    	$(REMOVE) $(TARGET).sym
    	$(REMOVE) $(TARGET).lnk
    	$(REMOVE) $(TARGET).lss
    	$(REMOVE) $(OBJ)
    	$(REMOVE) $(LST)
    	$(REMOVE) $(SRC:.c=.s)
    	$(REMOVE) $(SRC:.c=.d)
    	$(REMOVE) .dep/*
    
    
    
    # Include the dependency files.
    -include $(shell mkdir .dep 2>/dev/null) $(wildcard .dep/*)
    
    
    # Listing of phony targets.
    .PHONY : all begin finish end sizebefore sizeafter gccversion \
    build elf hex eep lss sym coff extcoff \
    clean clean_list program
    2. Die Übertragung sollte (so glaub ich) per Bascom-AVR gehen. Einfach das Hex-File auswählen und übertragen? (Mein Laptop hat kein Parallelport, es ist jedoch eine an der Dokingstation vorhanden, USB-ISP-Dongle kostet fast gleichviel wie ein Board) Die Übertragung mit dem Beispielprogramm hat funktioniert. Die Batteriespannung wird angezeigt, …

    3. Wieso gibt es immer noch kein Tutorial, wie man das C-Programm auf den Controller kriegt? Ist denn C++ so selten?

    Gruss
    Euer Adso

    PS: Im Forum habe ich nichts passendes gefunden.

  2. #2
    Erfahrener Benutzer Robotik Visionär Avatar von Hubert.G
    Registriert seit
    14.10.2006
    Ort
    Pasching OÖ
    Beiträge
    6.186
    Welchen Compiler verwendest du, C++ macht auf einem AVR wenig bis keinen Sinn.
    Verwende das AVR-Studio zum compilieren, dort kannst du auch deine Programme erstellen. Übertragen kannst du sie dann mit PonyProg, oder was du sonst verwenden willst.
    Grüsse Hubert
    ____________

    Meine Projekte findet ihr auf schorsch.at

  3. #3
    Neuer Benutzer Öfters hier
    Registriert seit
    19.10.2007
    Alter
    29
    Beiträge
    27
    RN-Control -> AtMega32

    Kannst du mir beschreiben, wieso C++ für AVR keinen Sinn macht? Da ich noch wenig Ahnung habe, dachte ich, dass ausser der Syntax kein grosser Unterschied herrscht. Der Asuro ist bekanntlich mit einem AtMega8 aufgebaut und wird vorallem in C programmiert.

  4. #4
    Erfahrener Benutzer Robotik Visionär Avatar von Hubert.G
    Registriert seit
    14.10.2006
    Ort
    Pasching OÖ
    Beiträge
    6.186
    Du hast es richtig geschrieben, vor allem in C programmiert, aber nicht in C++. C++ beinhaltet zwar den C Syntax aber doch mit einigen mächtigen Erweiterungen die auf einer µC-Plattform keinen Sinn machen, oder diese sogar bei weitem überfordern würde.
    Die Frage nach dem C-Compiler den du verwendest, hast du mir noch nicht beantwortet.
    Grüsse Hubert
    ____________

    Meine Projekte findet ihr auf schorsch.at

  5. #5
    Neuer Benutzer Öfters hier
    Registriert seit
    19.10.2007
    Alter
    29
    Beiträge
    27
    Das ist wahrscheinlich mein Problem. C++ ist in der "Einsteigerversion" sowieso nur C. Also das richtige für mich

    Mit allen Programmen hänge ich noch ein wenig. Von mir aus wäre Eclipse das richtige, leider hänge ich da noch. Beschrieben wird alles im Microcontrollerforum:
    http://www.mikrocontroller.net/articles/AVR_Eclipse

    Jetzt möchte ich jedoch entlich mal programmieren können.
    Mein Aufbau: jetzt per Parallelport vom Laptop über ISP-Dongle von robotikhardware.de auf die ISP-Schnittstelle des RN-Control 1.4 Board. (ISP Dongle hängt an LTP-1.)

    Bei der Software habe ich einiges an Problemen: Was empfehlt ihr, damit es grundsätzlich klappt mit der Programmierung? Tutorials helfen mir nicht wirklich weiter, da es noch beim Start hängt. Wie schon beschrieben: Bascom-AVR klappt hervorragend, leider möchte ich C. Compiler sollte WINAVR sein.

    Jetzt habe ich bereits den gesammten AVR-Kram ausprobiert: AVR Studio und Programmer's Notepad. Ich komme jedoch einfach nicht darauf, wie ich die Programme einstellen kann, damit die Programmierung klappt. Im Anhang habe ich direkt ein Bild der (fast) Standartkonfiguration und des Projekts erstellt im Programmer's Notepad erstellt. Leider klappt es hier überhaupt nicht. Programmer's Notepad scheint mir bisher nochBS ist Windows.

    Und noch was: Braucht ich irgendeinprogramm wie WINdude zum flashen?

    Und noch herzlichen Dank für die superschnellen Antworten.

    Gruss
    Euer Adso
    Miniaturansichten angehängter Grafiken Miniaturansichten angehängter Grafiken screenshot_3_programmer_s_notepad_-__main.c_.png  

  6. #6
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    7.555
    Hallo Adso,

    sicherlich kann Dir Hubert.G besser raten als ich, aber ich bin näher am Anfang als er - eben noch nicht soooo lang "im Geschäft" wie er. Daher ein paar Anmerkungen von mir.

    Zitat Zitat von adso
    ... Jetzt möchte ich jedoch entlich mal programmieren können ... Parallelport vom Laptop über ISP-Dongle von robotikhardware.de auf die ISP-Schnittstelle des RN-Control 1.4 Board ...
    Genauso ist es richtig.

    Zitat Zitat von adso
    ... Jetzt habe ich bereits den gesammten AVR-Kram ausprobiert: AVR Studio und Programmer's Notepad. Ich komme jedoch einfach nicht darauf, wie ich die Programme einstellen kann, damit die Programmierung klappt ...
    Diese Schwelle habe ich ganz einfach genommen - ich habe keinerlei Einstellungen (zum Übersetzene/Compilieren) gemacht.

    Mein Ausgangspunkt: AVRStudio als Programmierumgebung und WINAVR als GCC-Compiler. Meine Kenntnisse zum Compilieren - uralt, um es mit einem Wort zu sagen. Meine Kenntnisse in C: Null. Daher hatte ich in AVRStudio ein neues Projekt aufgemacht, den Controller gewählt, den Code (Beispiel aus dem Forum, nicht selbst erstellt) ins Codefenster gepackt und auf [F7] gedrückt. Den Rest machte "der Computer". Es klingt ein bisschen wie - und ist es auch - experimentelles Programmieren. Läuft oder läuft nicht.

    AVRStudio macht beim Einrichten des neuen Projektes einen Standard-Makefile in dem alles Mögliche, aber eben in Standardversion, drinsteht. Und es klappte.

    Zitat Zitat von adso
    ... Und noch was: Braucht ich irgendeinprogramm wie WINdude zum flashen? ...
    Dazu hatte ich PonyProg genommen (kostenlos erhältlich). Auch hier waren die Einstellungen ziemlich einfach, geht meist aus der on-board-Hilfe der Software hervor - ansonsten hatte ich im Forum gefragt.

    Dann hatte ich, glaube ich, das Beispielprogramm in C für die RNControl ins Editorfenster von AVRStudio geladen, die rncontrol.h ins Projektverzeichnis gestellt und compiliert. Flashen - und fertig. Danach kamen einzelne Änderungen um vorsichtig zu sehen, wie das eigentlich laufen sollte. Mittlerweile bin ich über die ersten Schritte hinaus und mein kleiner Roboter läuft - selbst programmiert. Ach ja, erste Fallen bei Textausgabe über RS232 an PC hatte mir Hubert.G repariert. Auch über andere Stolperstellen wurde mir von ihm und anderen geholfen.

    Viel Erfolg
    Ciao sagt der JoeamBerg

  7. #7
    Neuer Benutzer Öfters hier
    Registriert seit
    19.10.2007
    Alter
    29
    Beiträge
    27
    Wow, dankeschön.
    Bis jetzt hat alles funktioniert, selbst das übertragen habe ich hinbekommen. Leider ertönen lediglich einige tiefe Töne, und die Tasten haben keine Wirkung, obwohl ich das Beispielprogramm übertragen habe. Ich habe dazu das Hex-File aus /default genommen.
    Wenn ich das Beispielprogramm, das als Hex vorliegt, mit PonyProg übertrage, funktioniert das Board, wie es sollte.
    Wenn ich die Hex-Dateien anschaue, fällt mir auf, dass sie komplett unterschiedlich sind.
    Im Anhang habe ich nochmals ein Screenshot, wie das AVR Studio eingestellt ist.


    Zu sagen gibt es noch was: Die Version des Ponyprogs auf der Robotikhardware hat kein AtMega32. Es klappt jedoch mit einer neuen Version aus dem Internet.
    Miniaturansichten angehängter Grafiken Miniaturansichten angehängter Grafiken screenshot_20081127194527_2_rn-control_project_options.png  

  8. #8
    Benutzer Stammmitglied
    Registriert seit
    23.11.2008
    Beiträge
    32
    Also so wie ich das sehe sind das lediglich die Optionen für den Debugger (den ich übrigens nicht Empfehlen kann da er macht was er will). Es sei denn meine AVR Studio Kenntnisse sind total für die Katz.

    IdR musst du einfach oben rechts den Controllertyp auswählen - Programmieren und Kompilieren. Dann erstellt er eben das besagte .hex file im default Ordner. Wenn du das Überträgst sollte es vorrausgesetzt das Programm ist richtig, klappen.

    Achja: Die Frequenz wird im Programm selbst definiert vielleicht hast du das vergessen oder eben die falsche Frequenz eingestellt.

    #define F_CPU 4000000UL so oder so etwas aehnliches sollte irgendwo stehen. (Angepasst an den verbauten Quarz )

    Empfehlen kann ich fuer Anfänger www.mikrocontroller.net dort lernt man zumindest die Basics.

    Ansonsten gibt es vllt noch die Option das die .hex file aus dem Forum von einer neueren Version des Programms stammt und das Programm eben fehlerhaft ist.

    Schreib einfach selber ein kleines Programm um vllt einen Taster und eine LED "anzusteuern". Wenn das geht sollte der Rest auch funktionieren.

    P.S: Wenn ich falsch liege tuts mir leid

  9. #9
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    7.555
    Zitat Zitat von adso
    ... Bis jetzt hat alles funktioniert, selbst das übertragen habe ich hinbekommen ...
    Fein, das ist ja ein Fortschritt.

    Zitat Zitat von adso
    ... ertönen lediglich einige tiefe Töne, und die Tasten haben keine Wirkung, obwohl ich das Beispielprogramm übertragen habe ...
    *gggg* - zum Glück machst Du ähnliche Fehler wie ich.

    Tiefe Töne entstehen vermutlich dadurch, dass Du die Fuses nicht ordentlich eingestellt hast - ein typischer (Anfänger-) Fehler. Klick in PonyProg auf den Button "Security and Configuration Bits" - das ist der mit dem Vorhängeschloss. Dann klicke auf [Read] um die Fuses auszulesen. Jetzt steht wohl in dem weißen Kästchen neben CKDIV8 ein schwarzes Häkchen. Das wird ausgeklickt - das Kästchen ist jetzt weiß. CKDIV8 heißt, dass der Clock (Prozessortakt) durch 8 dividiert wird - daher die tiefen Töne! Jetzt könnte es sein, dass bei Dir noch neben JTAGEN auch ein schwarzes Häkchen steht. Auch dieses wird auf weiß geklickt. Danach die Fuses Zurückschreiben - also auf [Write] klicken. Vorsicht! Wenn das eine oder andere kritische Fuse falsch gesetzt ist, dann geht anschließend nix mehr. Also: Fuses lesen - und sicher sein, dass keinerlei Fehlermeldung kommt. Danach nur das tun, was hier steht - und Fuses zurückschreiben. Nun müsste das Testprogramm richtig laufen. >>> Sollte CKDIV8 NICHT angehakt sein, dann warte mit dem [Write]. Vielleicht liegts an dem angeblichen Takt 16800000 Hz. Dann diskutieren wir noch mal ! ?

    Zitat Zitat von adso
    ... Im Anhang habe ich nochmals ein Screenshot, wie das AVR Studio eingestellt ist ...
    Gut dokumentiert. Fein. Aber was ist das für ein seltsamer Prozessortakt: 16 800 000 Hz. Diese Frequenz ist wohl eher (D)ein Tippfehler ! ? ! ? Übrigens lasse ich mir auch Map und List Files erstellen. Die können (wenn man später etwas mehr weiß) ganz praktisch sein. Der Outputfile "RN-Control.etc" ist ein seltsamer Name. Meine Outputfiles heißen *.elf. Aber wenn Du so klar kommst - Du wirst es sicher später perfektionieren und alles nach "richtig" bringen.

    Viel Erfolg.
    Ciao sagt der JoeamBerg

  10. #10
    Neuer Benutzer Öfters hier
    Registriert seit
    19.10.2007
    Alter
    29
    Beiträge
    27
    Eine Freudensmeldung: ES FUNKTIONIERT! Danke tausendfach.

    Danke vielmals, die Fusebits sind zwar immer wieder beschrieben, es scheiterte jedoch am Ponyprog und am Tutorial: http://www.robomodules.de/portal/ind...?id=112&type=1

    Noch eine Frage: Wie kann man von C89 auf C99 umstellen, damit man eine Variable in einer For-Schleife bestimmen kann(for(int i=0, i<255, i++)?

    Gruss
    Euer Adso

Seite 1 von 3 123 LetzteLetzte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •