Hi und gleichmal sry falls die Frage blöd ist aber ich versuch das jetzt schon seit Tagen zu verstehen. Wie kann ich ein Assembler Programm auf einen Atmega Chip (der auf einem Schaltbrett steckt) brennen und dabei den Arduino Uno als ISP nutzen? Geht das überhaupt? Toll wäre eine richtige Schritt für Schritt Anleitung, welche Software ich installieren muss, wie ich aus meiner .asm Datei eine .hex Datei mache und auch wie ich die dann auf den Chip bringe. Ich hoffe ich verlange nicht zu viel. Danke schonmal im vorhinein. lg
PS: Die Arduino IDE und nasm hab ich installiert und ich arbeite unter Kali Linux (Debian) 64 Bit
https://tbspace.de/arduinoalsispprogrammer.html Der erste Teil beschreibt, wie du aus dem Arduino einen ISP machst. Nicht weiter spektakulär. Der zweite Teil in dem Artikel beschreibt nur das Erstellen eines neuen Arduinos mit avrdude (brauchst du nicht bzw. lohnt lediglich als grobe Info für die Benutzung von avrdude). Anschließend musst du so vorgehen, als würdest du einen blanken Atmega beschreiben wollen. Also fuses setzen, Code compilieren usw. Aber das ist im Prinzip unabhängig vom Arduino. Tutorials dafür gibt es auf dieser Seite oder google befragen.
Danke aber mir ist schon klar, das ich vorgehen muss als würde ich einen blanken Atmega programmieren - will ich ja auch! Die Befehle setzen aber immer .hex Dateien voraus. Ich bekomme keine .hex Dateien, wenn ich mit nasm kompiliere, das ist eines meiner Probleme.. lg
Arduino als ISP hab ich mir schon zusammengesteckt und eine .asm Datei hab ich auch. Wie muss ich die aber kompilieren? Im elf Format? Wie mach ich das bitte zu einer .hex Datei?
Ardunior schrieb: > Arduino als ISP hab ich mir schon zusammengesteckt und eine .asm > Datei > hab ich auch. Wie muss ich die aber kompilieren? Im elf Format? Wie mach > ich das bitte zu einer .hex Datei? Die avr-gcc-Toolchain ist dein Freund.
Außerdem verstehe ich bnicht ganz, wieso es eine .hex Datei sein muss, wenn ich doch ein bnäres Assemblerprogramm schreiben will. Bitte um Aufklärung mir fehlt sicher nur ein kleiner Funke Verstand und ich raff das. lg
@jonathan kannst du mir vielleicht sagen, wie ich es mit meinem Freund gcc Toolchain schaffen kann?
Ardunior schrieb: > Außerdem verstehe ich bnicht ganz, wieso es eine .hex Datei sein > muss, > wenn ich doch ein bnäres Assemblerprogramm schreiben will. Bitte um > Aufklärung mir fehlt sicher nur ein kleiner Funke Verstand und ich raff > das. lg Du schreibst dein Programm in Assemblersprache, und der Assembler übersetzt das in Maschinencode (die HEX-Datei). Diesen Maschinencode aus der HEX-Datei kannst du dann mit einem Programmiergerät auf den AVR schaffen. Übrigens ist NASM ein Assembler für x86, nicht für AVRs. Du brauchst einen AVR-Assembler und musst dein Programm entsprechend auch in der AVR-Assemblersprache schreiben. Mit x86-Maschinencode kann so ein AVR nichts anfangen.
Bitte erklärt es mir wie einem totalen Idioten (bin ich ja vllt auch) welche Programme und Befehle ich unter Debian (Kali Linux) brauche! mfg
Danke hab auch gerade erst gemerkt, das nasm für x86 ist. Dachte netwide assembler bedeutet für verschiedene architekturen, nicht nur x86 :P Was Assembler ist und wie es kompiliert wird weiß ich auch. Und wie ich es auf x86 Prozessoren zum laufen bekomme auch. Nur verstehe ich nicht, wie ich diese .hex Dateien erzeugen kann. Die werden doch auch aus .asm Dateien erzeugt, oder?
Ich nehm an, avr-gcc, avr-objcopy und avrdude hast du schon. Wenn ja, dann versuch mal dein Assemblerprogramm als .S Datei abzuspeichern (großes S) und kompiliere die dann mit
1 | avr-gcc demo.S -mmcu=atmega328 -Os -g -o demo.out |
in eine binäre Datei. Mit
1 | avr-objcopy -O ihex demo.out demo.hex |
"konvertierst" du sie zu einer .hex Datei. Zum Schluss mit
1 | avrdude -c arduino -p m328p -P <USB_PORT> -U flash:w:demo.hex |
auf den angeschlosenen Arduino laden. mfg
Jetzt hat es so ausgesehen als ob alles geklappt hat aber ich hab davor den Blink Sketch oben gehabt und der scheint noch immer oben zu sein also :S Kannst du mir nochmal helfen? root@kali:~# avrdude -c arduino -p m328p -P /dev/ttyACM0 -U flash:w:demo.hex avrdude: AVR device initialized and ready to accept instructions Reading | ################################################## | 100% 0.00s avrdude: Device signature = 0x1e950f avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed To disable this feature, specify the -D option. avrdude: erasing chip avrdude: reading input file "demo.hex" avrdude: input file demo.hex auto detected as Intel Hex avrdude: writing flash (150 bytes): Writing | ################################################## | 100% 0.04s avrdude: 150 bytes of flash written avrdude: verifying flash memory against demo.hex: avrdude: load data flash data from input file demo.hex: avrdude: input file demo.hex auto detected as Intel Hex avrdude: input file demo.hex contains 150 bytes avrdude: reading on-chip flash data: Reading | ################################################## | 100% 0.02s avrdude: verifying ... avrdude: 150 bytes of flash verified avrdude: safemode: Fuses OK avrdude done. Thank you.
Ganz vergessen: Viiiiielen Dank, jetzt bin ich zumindest schon um ein ganzes Eck weiter :DDDD
Hmm, sitzt der Chip auf einer Platte oder im Sockel vom Arduino? Ist es auch ein Atmega328p? Das sollte der sein, der von Haus aus drin ist.
:
Bearbeitet durch User
Ja es is der originale 328PU und steckt direkt auf dem arduino.
Hmm tut mir leid, dann kann ich dir nicht helfen, bin auch neu auf dem Gebiet. Viel Glück!
Jonathan S. schrieb: > Du schreibst dein Programm in Assemblersprache, und der Assembler > übersetzt das in Maschinencode (die HEX-Datei). Diesen Maschinencode aus > der HEX-Datei kannst du dann mit einem Programmiergerät auf den AVR > schaffen. Ich habe in der Überschrift deutlich geschrieben "mit Arduino" - das bedeutet ich habe kein Programmiergerät! mfg
Ardunior schrieb: > Ich habe in der Überschrift deutlich geschrieben "mit Arduino" - das > bedeutet ich habe kein Programmiergerät! Oben hast du geschrieben, dass du den Arduino als Programmiergerät programmieren möchtest. Ardunior schrieb: > und dabei den Arduino Uno als ISP nutzen? Bei der Arduino IDE ist ein Beispiel dabei, dass genau dieses tut.
Den objcopy Befehl von oben kannst du auch benutzten um ein binary zu erzeugen, nur andere Parameter. Dann nimmst du dieses binary und erzeugt daraus ein .c file das dir ein array mit den Daten initialisiert - dazu gibt es auch objcopy (zum erzeugen eines o-files mit einer section, das dürfte dir schwerer fallen) oder du schreibt ein Programm, das dies erledigt. Dann schreibst du ein Adruino Programm, das dieses Daten array benutzt um deinen atmega328 zu programmieren. ISP ist nichts anderes als SPI. Dazu liest du erst wie du SPI am adruino benutzt. Dann liest du das manual von atmega, das das ISP Protokoll beschreibt und schreibst ein byte nach dem anderen. Klar, das kann man jetzt auch Befehl für Befehl vorkauen, dann lernst du wenig. Es gibt natürlich auch Möglichkeiten den adruino direkt vom PC die Daten zu bekommen, dafür mag es auch schon fertige Programme geben, da lernst du aber nix. Wenn du einen rpi dein eigen nennst, da gibt es eine gepatchte avrdude Version, die das auch direkt kann.... Google programming attiny with rpi
Ein nettes Hallo mal sage (auch wenn der Beitrag schon etwas älter ist ...), also ... mit dem "reinen Arduino-UNO" ein Assembler-Programm zu erstellen und auf einen externen Chip wie z.B. den AT Tiny 45 zu übertragen ist auf jeden Fall möglich, ohne zusätzliche Software und ohne zusätzliches Programmier-Gerät. Erst gestern (06.10.) ist mir folgendes gelungen: Eine "grobe" Vorgehensweise: 1. Über "github" die zusätzlichen Cores für Tiny-Controller downloaden und in die Arduino-Software einbinden. 2. In der Original IDE (1.0.6) ein Programm mit "Inline-Assembler" schrieben. Anleitungen dazu direkt bei Atmel oder nongnu.org (englisch) 3. UNO mit dem Tiny45 auf dem Steckbrett korrekt verbinden (auch dazu gibt es viele Anleitungen im Netz). 4. Danach das an die Ports des Tiny 45 angepasste Programm vom UNO auf den Tiny übertragen (Bords: Tiny45 1 MHz, Programmer: Arduino als ISP ) 5. Bootloader für den Tiny 45 übertragen (falls noch nicht schon erfolgt) 6. Blink-Programm übertragen Als Test (weil ich extrem ungläubig bin) habe ich den UNO abgeklemmt, Batterie (4 x 1,2 V Akkus) angeklemmt ... und ich laufe mit dem blinkenden Steckbrett ohne UNO durchs Haus! Das Progi kann ich hier auflisten, eine Schaltung geht im Moment nicht, weil mir ein paar Dinge dazu fehlen:
1 | /* ------------------------------------------------------------------------- */ |
2 | /* Das berühmte "Blink-Programm", in Assembler */ |
3 | /* 06.10.2015, Rudi_DL5 */ |
4 | /* Controller: AT Tiny 45 */ |
5 | /* Netto: 32 Bytes (504 inkl. Bootloader) */ |
6 | /* ------------------------------------------------------------------------- */ |
7 | void setup() |
8 | {} |
9 | void loop() |
10 | { |
11 | asm volatile |
12 | ( |
13 | /* ------ I/O-Ports deklarieren ---------------------------------------- */ |
14 | "Setup: SBI %2, %3 \n\t" /* pinMode( 12, OUTPUT ); */ |
15 | /* ------ Dauerschleife "Blink" ---------------------------------------- */ |
16 | "Loop: SBI %[sfb], %[pb4] \n\t" /* digitalWrite( 12, HIGH ); */ |
17 | " RCALL Sekunde \n\t" /* delay( 1000 ); */ |
18 | " CBI %[sfb], %[pb4] \n\t" /* digitalWrite( 12, LOW ); */ |
19 | " RCALL Sekunde \n\t" /* delay( 1000 ); */ |
20 | " RJMP Loop \n\t" /* */ |
21 | /* ------ delay() ------------------------------------------------------ */ |
22 | "Sekunde: LDI r17, 33 \n\t" /* Etwa 1 Sekunde auf T.45: */ |
23 | "Aussen: LDI r18, 100 \n\t" /* repeat: r18 := 100; */ |
24 | "Mitte: LDI r19, 98 \n\t" /* repeat: r19 := 98; */ |
25 | "Innen: DEC r19 \n\t" /* repeat: dec( r19 ); */ |
26 | " BRNE Innen \n\t" /* until r19 = 0; */ |
27 | " DEC r18 \n\t" /* dec( r18 ); */ |
28 | " BRNE Mitte \n\t" /* until r18 = 0; */ |
29 | " DEC r17 \n\t" /* dec( r17 ); */ |
30 | " BRNE Aussen \n\t" /* until r17 = 0; */ |
31 | " RET \n\t" /* return; */ |
32 | /* ------ Compiler I/O ------------------------------------------------- */ |
33 | :: [sfb] "I" (_SFR_IO_ADDR(PORTB)), |
34 | [pb4] "I" (PORTB4), |
35 | "I" (_SFR_IO_ADDR(DDRB)), |
36 | "I" (DDB4) |
37 | ); |
38 | } |
Man muß natürlich aufpassen, welche Ports man wählt und welche Betriebsarten man einsetzen will. Nicht jeder Chip kann alles. Zum Beispiel ist beim Tiny 45 nur der PORTB nutzbar, der Tiny 2313 kann wiederum kein ADC. Aber alles in allem klappt das ganz gut mit dem Tiny 45, Tiny 84, Tiny 2313 und sogar mit einem Mega 328P "Standalone" auf einem Steckbrett ... Ich bin selbst überrascht, stehe erst am Anfang damit und erforsche noch weitere Tricks. Beste Grüße
Seufz, vor lauter Aufregung hat sich noch ein Fehler eingeschlichen (schäm): Punkt 4 sollte eigentlich nur heissen "Programm an die Ports des AT Tiny anpassen" (Zuerst muss natürlich der Bootloader mit 1 MHz oder mit 8 MHz drauf) Und "gestern" war erst der 05.10. .. ;-) ... Sorry Alles andere passt aber und die externen Chips (auch der mega328p) blinken munter vor sich hin.
Ich wusste gar nicht, dass der Bootloader sich dafür interessiert, was er lädt. Natürlich stehen die Teile meist auf Hex-Dateien, aber das sollte doch kein Problem sein. Programme à la "Irgendwas2Hex" sollte es doch wie Sand am Meer geben.
Wo finde isch die Software bzw. Bootloader für einen Atmega328 um ihn dan mithilfe der Arduino Software programmieren zu können
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.