Arduino als ISP nutzen um Assembler auf CHip zu bringen?

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?

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?

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?

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

Ja es is der originale 328PU und steckt direkt auf dem arduino.

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