Bonjour à tous,
J'aimerais programmer un arduino en assembleur, j'aimerais donc utiliser un arduino uno.
J'ai trouvé la liste des instructions en assembleur :
http://www.atmel.com/images/doc0856.pdf
Point de vue logiciel de programmation, j'ai entendu parler du ponyprog ou encore AVR Burn O Mat.
Pourriez-vous me dire si les deux programmes sont encore d'actualité ?
Bien à vous
Cédric
Bonne question... J'ignore s'il est possible de programmer directement le µc de la arduino via l'USB ou bien s'il faut impérativement passer par une carte de programmation externe par ICSP.
Coté logiciel, voit effectivement du coté de ponyprog ou avrdude.
Bonjour
Je ne connais pas ces logiciels.
En ce qui me concerne, je n'utilise que les outils de développement de l'Arduino pour développer en assembleur, soit en intégrant des directives asm dans le code C depuis l'IDE, soit en compilant les programmes en assembleur et en programmant le µC à l'aide des outils en ligne de commande fournis. Tout est documenté.
@PA5CAL -> Tu peux me donner la syntaxe permettant d'inclure de l'assembleur dans l'IDE d'arduino ? J'avais tenté, mais échec. Peut être un problème de version...
Salut Pa5cal,
Je suis super intéresser par ce que tu viens de me dire. Si je comprends bien , tu ouvre l'IDE arduino , tu programmes en assembleur et tu envois le tout via USB ?
Ou ce trouve cette documentation ? Sur le site arduino.cc ?
Bien à toi
Ps: Merci a tous de vos réponse.
La syntaxe et les explications relatives à l'utilisation de la directive asm peuvent être trouvées dans le manuel de GCC.
La forme générale est :
où:Code:asm(code : output operand list : input operand list [: clobber list]);
- code est une chaîne de caractère représentant le code source assembleur de la routine
- output operand list est la liste (éventuellement vide) des valeurs de sortie de la routine
- input operand list est la liste (éventuellement vide) des valeurs d'entrée de la routine
- clobber list, qui est optionnelle, est la liste des registres utilisés par la routine que le compilateur doit préserver
Les types de valeurs d'entrée ou de sortie (registres ou constantes) sont déclarés dans les listes de la manière suivante :
avec éventuellement un préfixe :Code:┌────────────┬───────────────────────────────────────┬────────────────────┐ │ Constraint │ Used for │ Range │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ a │ Simple upper registers │ r16 to r23 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ b │ Base pointer registers pairs │ y, z │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ d │ Upper register │ r16 to r31 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ e │ Pointer register pairs │ x, y, z │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ q │ Stack pointer register │ SPH:SPL │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ r │ Any register │ r0 to r31 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ t │ Temporary register │ r0 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ w │ Special upper register pairs │ r24, r26, r28, r30 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ x │ Pointer register pair X │ x (r27:r26) │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ y │ Pointer register pair Y │ y (r29:r28) │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ z │ Pointer register pair Z │ z (r31:r30) │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ G │ Floating point constant │ 0.0 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ I │ 6-bit positive integer constant │ 0 to 63 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ J │ 6-bit negative integer constant │ -63 to 0 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ K │ Integer constant │ 2 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ L │ Integer constant │ 0 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ l │ Lower registers │ r0 to r15 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ M │ 8-bit integer constant │ 0 to 255 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ N │ Integer constant │ -1 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ O │ Integer constant │ 8, 16, 24 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ P │ Integer constant │ 1 │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ Q │ (GCC >= 4.2.x) A memory address based │ │ │ │ on Y or Z pointer with displacement. │ │ ├────────────┼───────────────────────────────────────┼────────────────────┤ │ R │ (GCC >= 4.3.x) Integer constant. │ -6 to 5 │ └────────────┴───────────────────────────────────────┴────────────────────┘Dans le code source, les valeurs d'entrée et de sortie apparaissent sous la forme d'un identifiant généralement constitué d'un numéro précédé d'un « % », mais qui peut également inclure une lettre pour spécifier un octet particulier dans le cas d'une valeur constituée de plusieurs octets.Code:┌──────────┬───────────────────────────────────────────────────────────┐ │ Modifier │ Specifies │ ├──────────┼───────────────────────────────────────────────────────────┤ │ = │ Write-only operand, usually used for all output operands. │ ├──────────┼───────────────────────────────────────────────────────────┤ │ + │ Read-write operand │ ├──────────┼───────────────────────────────────────────────────────────┤ │ & │ Register should be used for output only │ └──────────┴───────────────────────────────────────────────────────────┘
Par ailleurs, on peut désigner des registres spéciaux :Code:┌──────────────┬─────────────────────────────────────────┐ │ Symbol │ Register │ ├──────────────┼─────────────────────────────────────────┤ │ __SREG__ │ Status register at address 0x3F │ ├──────────────┼─────────────────────────────────────────┤ │ __SP_H__ │ Stack pointer high byte at address 0x3E │ ├──────────────┼─────────────────────────────────────────┤ │ __SP_L__ │ Stack pointer low byte at address 0x3D │ ├──────────────┼─────────────────────────────────────────┤ │ __tmp_reg__ │ Register r0, used for temporary storage │ ├──────────────┼─────────────────────────────────────────┤ │ __zero_reg__ │ Register r1, always zero │ └──────────────┴─────────────────────────────────────────┘
Voici un exemple de code :Ici, %a0 représente l'octet de poids faible (a) de la première (0) et unique valeur passée en paramètre, qui est la variable d'entrée « ptr », de type pointeur ("e" = Pointer register pairs).Code:asm volatile ( "cli" "\n\t" "ld r24, %a0" "\n\t" "inc r24" "\n\t" "st %a0, r24" "\n\t" "sei" : : "e" (ptr) : "r24" );
Il n'y a pas de valeur de sortie.
Le registre r24 est sauvegardé par le compilateur en dehors de la routine.
La chaîne de caractère représentant le code étant écrit en langage C, il est nécessaire d'ajouter « \n\t » pour indiquer chaque saut de ligne.
Merci ! Je pense que mes problèmes venaient du manque de "\n\t".
Je peux mettre n'importe quel code, des étiquettes de ligne, des rjump et autres avec une telle structure ?
Voici un autre exemple :Dans le code :Code:asm volatile ( "in %0,%1" "\n\t" "out %1,%2" "\n\t" : "=&r" (input) : "I" (_SFR_IO_ADDR(port)), "r" (output) );
- %0 représente la variable de sortie input, de type registre (r=register), utilisée par la routine seulement en écriture (=) et en sortie (&)
- %1 représente la valeur d'entrée constante correspondant à l'adresse de port, de type entier sur 6 bits ("I")
- %2 représente la variable d'entrée output, de type registre ("r")
Il n'y a pas de registre sauvegardé par le compilateur, et le dernier « : » a été omis.
Oui.Envoyé par Yoruk
Dans le principe, c'est un bout de code assembleur (le langage) qui est reconstitué à partir des indications fournies dans la directive asm, puis qui est soumis à l'assembleur (le logiciel) pour créer le code exécutable. Par conséquent, on peut mettre dans la partie "code" de la directive tout ce qui peut être compris au final par l'assembleur (le logiciel).
Pour éviter de se retrouver avec des conflits entre des étiquettes portant le même nom, notamment quand on a affaire à un grand projet, on peut utiliser le suffixe « %= ».
Voici un exemple de code :Code:void delay(uint8_t ms) { uint16_t cnt; asm volatile ( " \n" "L_dl1%=: \n" " mov %A0, %A2 \n" " mov %B0, %B2 \n" "L_dl2%=: \n" " sbiw %A0, 1 \n" " brne L_dl2%= \n" " dec %1 \n" " brne L_dl1%= \n" : "=&w" (cnt) : "r" (ms), "r" (delay_count) ); }
Tu n'as pas de \t dans ton dernier exemple...?
Hmmm.. Je crains d'avoir mal saisi le %=.... Ceci pourrait fonctionner ?
Code:void delay(uint8_t ms) { uint16_t cnt; asm volatile ( " \n" "L_dl1: \n" " mov %A0, %A2 \n" " mov %B0, %B2 \n" "L_dl2: \n" " sbiw %A0, 1 \n" " brne L_dl2 \n" " dec %1 \n" " brne L_dl1 \n" : "=&w" (cnt) : "r" (ms), "r" (delay_count) ); }
Le « \t » dans mon premier exemple correspond à une tabulation au début de la ligne suivante. Mais rien n'empêche de formater le code assembleur différemment, notamment à l'aide d'espaces en début de ligne comme je l'ai fait dans mon dernier exemple.
Oui, tout-à-fait.
Mais dans ce cas, on court le risque (faible, il est vrai, mais pas nul) qu'une autre étiquette portant le même nom puisse exister ailleurs dans le projet, écrite par le programmeur, issue d'une bibliothèque, ou bien générée automatiquement.
D'accord ! De toute façon, je met toujours des noms d'étiquettes" bien français"
