En C on passe à 156 octets avec tempo, ou 224 octets avec timer (cf post de mkh. mourad en page 4).Envoyé par Carthorix
C'est un peu plus, mais on gagne en lisibilité (et le ratio sera certainement plus faible pour un programme plus complexe).
Pour le blink avec tempo soft de mkh.mourad, le code assembleur généré est le suivant :
Pour la tempo, j'ai pas regardé dans le détail (mais en général c'est des fonctions assez optimisées).Code:--- H:\Dev\Robot\Arduino\test\test\Debug/.././test.c --------------------------- { DDRB |= 1 << Led13; 0000003D SBI 0x04,5 Set bit in I/O register LedToggle; 0000003E LDI R25,0x20 Load immediate --- No source file ------------------------------------------------------------- 0000003F IN R24,0x05 In from I/O location 00000040 EOR R24,R25 Exclusive OR 00000041 OUT 0x05,R24 Out to I/O location --- e:\developpement\atmel\atmel toolchain\avr8 gcc\native\3.4.2.1002\avr8-gnu-toolchain\bin\../lib/gcc/avr/4.7.2/../../../../avr/include/util/delay.h __builtin_avr_delay_cycles(__ticks_dc); 00000042 SER R18 Set Register 00000043 LDI R19,0xD3 Load immediate 00000044 LDI R24,0x30 Load immediate 00000045 SUBI R18,0x01 Subtract immediate 00000046 SBCI R19,0x00 Subtract immediate with carry 00000047 SBCI R24,0x00 Subtract immediate with carry 00000048 BRNE PC-0x03 Branch if not equal 00000049 RJMP PC+0x0001 Relative jump 0000004A NOP No operation 0000004B RJMP PC-0x000C Relative jump
Pour le reste, difficile de faire beaucoup plus court (sauf peut être la lecture du registre de sortie dont la valeur doit à priori être connue, mais pourrait dans un soft plus complexe être modifiée par une autre fonction).
Une bonne partie du code supplémentaire vient de l'initialisation de l'ensemble des vecteurs d'interruption, même si ils ne sont pas utilisés. J'ai un peu de mal à voir le fonctionnement exact, j'ai l'impression qu'il y a des sauts inutiles, mais à priori ils redirigent tous vers le début du main.
Bonjour,
Pas à 100% car je ne sais pas si c'est un quartz ou un résonateur céramique.
Je pense plutôt que c'est un résonateur car il n'y a aucune capa céramique à chaque pin.
Mais j'ai monté un quartz en l'air de fréquence quelconque et là j'ai un beau signal sinusoïdal.
J'ai commandé un quartz 16MHz, on verra bien ...
Bonjour,
Sur l'Arduino c'est 1084 octets exactement, je trouve que ça fait beaucoup.
Tiens une question : Est ce que sur l'Arduino on peut visualiser le ficher .asm (si) produit dans la compilation ?
hello,
ce n'est pas l'Arduino qui va t'afficher le fichier .asm (mais, ça, tu le savais déjà!)
ce sont les directives que tu transmets au compilateur, soit en direct (ligne de commande), soit au travers d'un élément à qui tu as donné la main et que tu ne maîtrises pas forcément: il est facile de faire totalement confiance à studio ou au makefile qui peuvent avoir un "nettoyage" agressif en fin de tâche
avr-gcc par exemple nécessite simplement l'option -c avec le nom de la destination p. ex. file.lst
saluts
Avec l'IDE 1.5.7, le code prend 1030 octets pour un Arduino Uno.
En plus du programme lui-même, on y trouve :
- les vecteurs d'interruption,
- les routines de mise en place de la pile, d'initialisation des registres, d'initialisation de la BSS
- la routine de traitement de l'interruption timer pour le comptage du temps
- la fonction de délai utilisant le comptage du temps
- les fonctions de manipulation des pins d'entrée/sortie et des PWM
- la fonction main du C
Pour un Arduino Leonardo, le code prend 4798 octets (le µC intègre l'interface USB, qu'il faut également gérer).
Dernière modification par PA5CAL ; 02/10/2014 à 07h51.
... Et là-dedans, on n'a pas compté la taille du bootloader.
Mais Arduino, ce n'est pas un kit de programmation pour µC standalone. C'est un système de cartes à µC auto-programmable en C/C++, ce qui est tout-à-fait différent.
Dernière modification par PA5CAL ; 02/10/2014 à 07h57.
Ça aurait été intéressant (pour moi) de voir ce que la compilateur avait mis dans le code
Mais, bon, Avr dude en ligne de commande .. ça me gonfle sérieusement.
J'ai l'impression de revenir 20 ans en arrière sous Exormax (68000).
Bonne journée
Tu as quoi comme options pour flasher ton micro ? (d'AVRDUDE ou autre)
En ce qui concerne, j'ai fait un fichier de commande (batch) afin d'avoir ces informations en un simple double-clic juste après la compilation. Dans le principe, il suffit de :
- trouver le dernier dossier build* dans le dossier temporaire de l'utilisateur courant
- trouver les fichiers *.elf de ce dossier
- traiter ces fichiers avec l'outil avr-objdump (fourni avec Arduino) en utilisant les options souhaitées (-d : désassemblage de l'exécutable, -S : source+désassemblage, -x : contenu des entêtes, -s : dump complet des sections), en redirigeant la sortie vers un ou plusieurs fichiers texte
- afficher les fichiers texte obtenus.
Par exemple, sous Windows 7, le batch ressemble à ça :Le principe est le même sous Linux et sur Mac. Seules les commandes et le chemin des fichiers changent.Code:c: cd "%ProgramFiles%\Arduino" for /f %%a in ('dir /b /ad /od %TEMP%\build*') do set recent=%%a for /f %%b in ('dir /b %TEMP%\%recent%\*.elf') do ( hardware\tools\avr\bin\avr-objdump.exe -d "%TEMP%\%recent%\%%b">"%TEMP%\%recent%\%%b.asm" start %windir%\notepad.exe "%TEMP%\%recent%\%%b.asm" hardware\tools\avr\bin\avr-objdump.exe -S "%TEMP%\%recent%\%%b">"%TEMP%\%recent%\%%b.dump" echo. >> "%TEMP%\%recent%\%%b.dump" echo ================================================== >> "%TEMP%\%recent%\%%b.dump" hardware\tools\avr\bin\avr-objdump.exe -x "%TEMP%\%recent%\%%b">>"%TEMP%\%recent%\%%b.dump" echo ================================================== >> "%TEMP%\%recent%\%%b.dump" hardware\tools\avr\bin\avr-objdump.exe -s "%TEMP%\%recent%\%%b">>"%TEMP%\%recent%\%%b.dump" start %windir%\notepad.exe "%TEMP%\%recent%\%%b.dump" )
Dernière modification par PA5CAL ; 02/10/2014 à 20h24.
... Le même fichier de commande, sur Mac, à placer dans le même dossier que Arduino.app :
Code:#!/bin/bash DUMPCMD="`dirname \"$0\"`" DUMPCMD="`( cd \"$DUMPCMD\" && pwd )`" if [ -z "$DUMPCMD" ] ; then exit 1 fi DUMPCMD=$DUMPCMD/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/avr-objdump for DIRLIST in `ls -trd1 /var/folders/*/*/-Tmp-/build*` do BDIR=${DIRLIST} done for FILE in ${BDIR}/*.elf do if [ -f ${FILE} ] then ${DUMPCMD} -S "${FILE}" > "${FILE}.dump" echo >> "${FILE}.dump" echo ============================================================ >> "${FILE}.dump" ${DUMPCMD} -x "${FILE}" >> "${FILE}.dump" echo >> "${FILE}.dump" echo ============================================================ >> "${FILE}.dump" ${DUMPCMD} -s "${FILE}" >> "${FILE}.dump" open -t "${FILE}.dump" ${DUMPCMD} -d "${FILE}" > "${FILE}.asm" open -t "${FILE}.asm" fi done
Bonjour PA5CAL,
Merci pour tout ça, mais ça fait beaucoup d'un coup à digérer ...
Je ne suis pas du tout au même niveau.
Je viens de recevoir une nouvelle carte Mega2560, qui a fonctionné du premier coup, et je m'y met doucement en suivant pas à pas un "instructable" qui m'intéresse.
En fait comme vous avez du le comprendre j'ai choisi l'Arduino, non pour apprendre l'électronique ou la programmation mais pour réaliser un petit système robotique bien précis.
Cela dans un souci d'efficacité et de rapidité qui me permette de développer quelque chose d'exactement adapté à mes besoins avec la facilité de modifier mes paramètres via USB.
Je me documente et je lis car il y a énormément de projets similaires (rarement achevés d'ailleurs) mais qui donnent de bonnes idées.
Je reviendrai en parler quand j'aurais un peu progressé ....
Bonjour à tous,
Je me suis inscris sur ce forum précisément pour cette discussion car je souhaite participer à votre recherche en matière de « programmer un ci en amateur sans la bibliothèque arduino ».
C'est marrant parce que jusqu’à maintenant je ne me suis jamais plus que cela intéressé à l'électronique en tant que composant (on ne peut pas être partout vous me direz), et depuis peu j'ai eu envie de réaliser un petit projet électronique donc je m'y suis mis, comprendre une résistance, un condo, une diode, jusqu'à en venir finalement à me dire, mais comme cela fonctionne un circuit intégré ?
J'ai voulu en savoir plus pour la raison suivante, je fait du C ISO (C pur comme on dit), donc avec les bibliothèques standard et normées du c, ce qui est la base maintenant, car je pense que pas grand monde sur terre ne s’amuserait aujourd'hui à reprogrammer les bibliothèques du C.
Première chose qui m'est venu à l'esprit, arduino. Arduino est un projet de bibliothèque et dans une moindre mesure de cartes électroniques, sous la forme de kits de base que je qualifie de marketo industrialo communautaire à consonance facile d'accès pour mr tout le monde qui réfléchis un peu, donc effectivement, j'avais déjà à l'époque entendu parlé de arduino de part la publicité et le réseau de distribution qui gravite autour…
J'ai donc acheté une petite arduino nano, parce qu'on m'a dit qu'il est possible et il est courant de la programmer en langage C. J'ouvre l'IDE arduino jute parce que à ce stade je ne connais rien d'autre pour communiquer un programme avec cette carte, et me dit que de toute façon je m'en passerais d'ici peu puisque généralement, étant dans le monde linux, je fait beaucoup de choses dans le terminal, compression de vidéos, compilation de langages, etc.
A ce moment je ne comprend pas ou est ma fonction main qui dois retourner un int, donc je vais voir cette fameuse fonction setup et loop qu'on nous dit de rentrer pour un fonctionnement minimal du circuit intégré, je vois à présent qu'on est en présence d'une plus ou moins vaste bibliothèque, quelle s'appelle arduino, que c'est du C et Cpp, et que c'est pas super super bien programmé franchement (avis personnel sur le sujet).
Après pour ce qui a été dit, je pense que arduino n'est pas un langage et que quand on est dans l'ide on ne programe pas de l'arduino, qui serait un langage, on programme bel et bien du Cpp qui appel les fonctions dans les classes de la bibliothèque arduino. Et sinon pour le bug du Timer du C, ce ne serait pas plutôt une variable publique de la classe Timer qui serait appelée et redéfini depuis la bibliothèque arduino ?
Bref, je reviens à vous du coup, j'aime le débat de ce fil de discution, il y a pleins de gens passionnés, des gens qui essayent et qui font progresser la compréhension de la problématique qui se pose à nous, c'est un peu dommage le semblant de clash qu'il y a eu entre deux intervenants, mais bon ce n'est pas grave.
Je trouve ça marrant également que *Carthorix ici présent, le roi de l'assembleur, et l'amoureux de la pureté de cette syntaxe bas niveau si je puis dire, s’achète une carte arduino et sans doute va programmer le micro contrôleur en C, pour faire un projet abouti d'une certaine complexité (il me semble que tu parlais de robot). Parce que oui évidement, allumer et éteindre une led, ou contrôler la température d'un four, comme il a été dit, en assembleur, pourquoi pas, on y arrive sans passer des plombes, mais programmer le comportement d'un robot dans sa totalité en assembleur ? J'ai envie de dire, bon courage, certainement que cela existe mais je pense que cela devient une prise de temps et d'énergie considérable pour arriver à nos fins. Parce que si on suis cette logique, ou est la limite finalement ? Pourquoi ne pas écrire directement des bits ? Pourquoi ne pas fabriquer les composants au lieu de les acheter à notre boutique d'électronique du coin, c'est vrai, un système logique on peu le faire avec un cours d'eau et quelques bouts de bois en guise de porte logique, comme transistor…
Non je pense réellement que le C pur est une base valide et seine, et que le Cpp est génial par son coté objet, je ne comprend pas pourquoi certains veulent interdire le Cpp en programmation de circuits intégrés, car qu'est ce que le Cpp si ce n'est du C qui dispose du fait qu'on peut appeler une suite de fonction encapsulé dans des objets, qu'on appelle finalement classes.
Bref j’attends votre retour sur mon point de vue en tout cas pour pouvoir progresser.
Donc, continuons, pour réaliser mon petit projet je dois afficher des choses sur des afficheurs, c'est la communication visuelle avec l'utilisateur que j'ai choisis, donc j'ai programmé une petite bibliothèque en Cpp, que j'ai appelé max7219, qui permet de contrôler des afficheurs à leds, leds qui sont pilotées via justement un composant max7219. La bibliothèque permet pas mal de choses (petite vidéo à venir), elle fait quelque chose comme 400 lignes, mais seulement quelques lignes sont des fonctions de la bibliothèque arduino, à savoir :
pinMode
digitalWrite
shiftOut
Et c'est tout.
En Cpp dans votre fonction main, si vous souhaitez afficher un nombre voila comment elle fonctionne :
// On déclare un objet Max7219
Max7219 myLedDisplay = Max7219 (nombre total d'afficheurs, pin din, pin load, pin clock);
// On demande d'afficher un nombre avec certaines options d'affichage
myLedDisplay.number (afficheur numéro ?, nombre, bourrage de zéros, calage du nombre à gauche ou à droite, afficher le nombre si possible du digit x à y, luminosité, etc...);
Deux lignes. Bien sur ceux qui sont familiers au C ou Cpp savent déjà tout cela, mais mon discours s'adresse plutôt à ceux sur la discussion que j'ai vue et qui sont supers pros en assembleur par exemple, mais qui se refuseraient au C et Cpp. Je pense comme beaucoup le pensent, que malgré le coté super pratique du C et Cpp, cela reste un langage tout de même proche du matériel, si je veux écrire du binaire dans du C je le peux, et surtout on y est de toute façon obligé quand on programme une bibliothèque qui pilote un max7219 par exemple. Le C c'est vraiment la partie logistique, ce sont les fonctions software, l'atmel 328 ou le max 7219 on eux aussi des fonctions, saufs qu'elles sont hardware.
Finalement un programme de nos jours ce sont des fonctions software qui interagissent avec des fonctions hardwares, c'est pour cela et dans cette logique qu'on peut créer plus facilement des robots supers compliqués.
Si je reviens à notre idée commune (pour la majorité d'entres nous), la bibliothèque arduino ne nous intéresse pas, et je souhaite passer ma bibliothèque max7219 en full C et Cpp ISO, cela signifie que je dois réécrire pinMode, digitalWrite, shiftOut, et me plonger dans le cambouis des classes dagalasses de l'arduino pour en comprendre le fonctionnement. Parce que j'imagine bien que ce n'est pas en réécrivant juste ces trois fonctions que j'aurais accès à un système d'abstraction équivalent à arduino, je pense effectivement que ça va comme qui dirait bugger.
Bref, comment faire, par ou commencer ?
Dois je passer des semaines voir des mois sur les bibliothèques arduino et réécrire juste ce qu'il me faut pour pouvoir me passer de cette dite bibliothèque et faire fonctionner par exemple une led en langage C ?
J'ai du mal avec le datasheet de l'Atmega328P et ses 448 pages de pdf parce que c'est la première fois que j'en lis, je ne suis pas ingénieur, comment faire pour reproduire le fonctionnement de la fonction pinMode de l'arduino en lisant ce datasheet ?
Merci d'avance pour vos réponses !
Dernière modification par sylvainmahe ; 10/10/2014 à 22h43.
C'est marrant parce que c'est peut être moi qui me fait des idées sur la complexité des fonctions de base de la bibliothèque arduino, je vais vérifier le reste dans les .h mais quand on voit ça, ça tiens quand même dans rien du tout pratiquement et c'est facilement compréhensible:
A voir après pour le reste c'est à dire l'initialisation de la bibliothèque arduino, par quels tas de fonctions cela passe (le fameux init(); dans le main).Code:void pinMode(uint8_t pin, uint8_t mode) { uint8_t bit = digitalPinToBitMask(pin); uint8_t port = digitalPinToPort(pin); volatile uint8_t *reg, *out; if (port == NOT_A_PIN) return; // JWS: can I let the optimizer do this? reg = portModeRegister(port); out = portOutputRegister(port); if (mode == INPUT) { uint8_t oldSREG = SREG; cli(); *reg &= ~bit; *out &= ~bit; SREG = oldSREG; } else if (mode == INPUT_PULLUP) { uint8_t oldSREG = SREG; cli(); *reg &= ~bit; *out |= bit; SREG = oldSREG; } else { uint8_t oldSREG = SREG; cli(); *reg |= bit; SREG = oldSREG; } } void digitalWrite(uint8_t pin, uint8_t val) { uint8_t timer = digitalPinToTimer(pin); uint8_t bit = digitalPinToBitMask(pin); uint8_t port = digitalPinToPort(pin); volatile uint8_t *out; if (port == NOT_A_PIN) return; // If the pin that support PWM output, we need to turn it off // before doing a digital write. if (timer != NOT_ON_TIMER) turnOffPWM(timer); out = portOutputRegister(port); uint8_t oldSREG = SREG; cli(); if (val == LOW) { *out &= ~bit; } else { *out |= bit; } SREG = oldSREG; }
J'aime bien aussi le:
if (port == NOT_A_PIN) return;
Les mecs d'arduino ne veulent pas qu'on crame le microcontrolleur
Dernière modification par sylvainmahe ; 10/10/2014 à 23h12.
Hello,
Ce sont des codes pour un processeur 8 bits possédant quelques K de mémoire, très peut d'instructions différentes, pas de DMA, ni de mode protégé, ni de processeur mathématiques, ...
Je découvre aussi Arduino.A voir après pour le reste c'est à dire l'initialisation de la bibliothèque arduino, par quels tas de fonctions cela passe (le fameux init(); dans le main).
J'aime bien aussi le:
if (port == NOT_A_PIN) return;
Les mecs d'arduino ne veulent pas qu'on crame le microcontrolleur
S'il s'agit simplement de set/clear des bits, digitalWrite peut être avantageusement remplacé par
Même lignes bitClear pour resetter le bitCode:digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level) asm ("sbi ??0x18, 5"); // PORTB = ??0x18, bit13 = pin5 portB je doute de 0x18 à verifier asm("sbi %0,%1" : : "I" (_SFR_IO_ADDR(PORTB)) , "I" (5) ); bitSet(PORTB, 5);
Les trois dernières lignes compilent en une instruction assembleur sbi PORTB, 5, digitalWrite ... beaucoup d'instructions
Le précompilateur d'Arduino est aussi très pauvre, je voulais
#define PIN15 (PORTB, 5)
et ben non y veut pas
Je ____pense____ que le PB de l'IDE Arduino est LIBC-AVR de GCC dont la dernière version date de ??2011?? Donc tout ce qui utilise GCC souffrira des mêmes lourdeurs ?????? Mais je n'en suis aps certain.
Biname
Intéressant, on avance !
Effectivement libc avr est pas tout jeune comme tu le dis..
Tiens je viens de tomber sur ce sujet:
http://balau82.wordpress.com/2011/03...uno-in-pure-c/
C'est bizarre je pensais vraiment qu'il fallait écrire DES TRUCS DE FOU en avr c pour pouvoir envoyer du +5v sur une pin.Code:#include <avr/io.h> #include <util/delay.h> enum { BLINK_DELAY_MS = 1000, }; int main (void) { /* set pin 5 of PORTB for output*/ DDRB |= _BV(DDB5); while(1) { /* set pin 5 high to turn led on */ PORTB |= _BV(PORTB5); _delay_ms(BLINK_DELAY_MS); /* set pin 5 low to turn led off */ PORTB &= ~_BV(PORTB5); _delay_ms(BLINK_DELAY_MS); } return 0; }
Donc au final, si je souhaite configurer la pin0 digitale en output (PD0 sur l'atmega328p), il suffirait de faire:
ou si on ne veut pas toucher à une précédente initialisation des pins on met un petit caractère pipe:Code:DDRD = B00000001;
Si on en croit ce document:Code:DDRD |= B00000001;
http://arduino.cc/en/Reference/PortManipulation
Donc avec juste ceci ce serait plié pour le pinMode ? A mon avis je dois faire erreur, et vous allez très certainement me remettre dans le droit chemin, ça ne peut pas être aussi simple !
5 minutes plus tard...
MAIS C'EST UN TRUC DE FOU !
shiftOut ce n'est que cette merde la????
C'est à dire la fonction digitalWrite hyper simple qu'on à déjà décortiqué tout à l'heure mais dans une boucle...Code:void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val) { uint8_t i; for (i = 0; i < 8; i++) { if (bitOrder == LSBFIRST) digitalWrite(dataPin, !!(val & (1 << i))); else digitalWrite(dataPin, !!(val & (1 << (7 - i)))); digitalWrite(clockPin, HIGH); digitalWrite(clockPin, LOW); } }
Si tout ça ce n'est que cela, je crois qu'on va tous faire de l'atmel sans l'ardu machin en pure C vite fait bien fait
A moins que ce que vous souhaitez vous c'est programmer sans les libs avr c?
Sinon pour digitalRead ou Write, je trouve cela pas très beau ce qu'il ont fait:
2 fonctions (si on part de digitalRead) et 2 macros? Ca fait beaucoup de choses imbriqués non?Code:#define digitalPinToPort(P) ( pgm_read_byte( digital_pin_to_port_PGM + (P) ) ) #define digitalPinToBitMask(P) ( pgm_read_byte( digital_pin_to_bit_mask_PGM + (P) ) ) #define digitalPinToTimer(P) ( pgm_read_byte( digital_pin_to_timer_PGM + (P) ) )
Merci d'avance
Je pense que, comme d'autres avant toi dans cette discussion, tu arrives avec l'idée préconçue qu'Arduino présente des caractéristiques qui répondent à tes besoins particuliers.
Au risque de me répéter, l'intérêt d'Arduino réside dans la possibilité de mettre en œuvre, vite et avec peu de moyens, des éléments logiciels et matériels pour réaliser des maquettes ou des appareils fonctionnels. C'est en quelque sorte un jeu de Légo™ micro-informatique pour le débutant ou l'amateur, sans soudure ni investissement dans des moyens de développement professionnels, et destiné à l'initiation ou au bricolage. Cette immersion rapide dans le domaine technique a pour but d'atteindre rapidement des résultats tangibles en terme de réalisation, mais pas en terme d'apprentissage académique des métiers de développement, ni de découverte des matériels, méthodes et outils logiciels disponibles pour l'industrie.
Bref, Arduino n'est pas fait pour apprendre le C ni l'électronique. Il faut déjà avoir quelques bases d'algorithmie, de syntaxe C ou C++ et éventuellement d'électricité pour l'utiliser, mais il a été conçu pour pouvoir démarrer et aboutir avec le moins de connaissances possibles.
D'ailleurs, sur le principe, ce n'est pas en observant le cas très particulier du microcontrôleur qu'on peut apprend l'électronique numérique, et encore moins l'électronique d'un point de vue plus général. Ce n'est pas non plus en programmant un petit système très limité et très spécifique, qui plus est à l'aide d'un compilateur très permissif vis-à-vis de la norme, qu'on peut s'exercer et acquérir une expérience significative en terme d'informatique générale.
A priori, Arduino ne sert pas à programmer des microcontrôleurs, mais des cartes spécifiques, estampillées "Arduino", répondant à des choix imposés par ses concepteurs. Le logiciel et le matériel ont été développés dans ce sens (certaines options du µC ont de ce fait été rendues inexploitables), et l'utilisateur qui ne souhaiterait pas se conformer à ces choix serait contraint d'apporter des modifications conséquentes, qui rendraient caduc le label "Arduino".
Tu proposais par exemple de manipuler la pin 0. Mais sur les cartes Arduino, cette pin est dédiée à la liaison série, et elle est la plupart du temps déjà connectée au système de programmation, lequel est interrogé à chaque démarrage (bootloader). Sa réutilisation n'est pas impossible, mais exige de prendre certaines précautions.
De même, le premier timer (0) est configuré et utilisé d'emblée comme une base de temps générale.
Le recours à la plupart des fonctions de base Arduino force également la configuration et l'utilisation de ressources du microcontrôleur selon des modalités particulières.
Il y a toujours un indicateur lumineux (L) connecté sur la pin 13, l'horloge et le reset sont toujours externes, etc. .
Bref, on ne fait pas ce qu'on veut, mais on peut créer rapidement et facilement des projets avec ce qui a été prévu. Et ceux qui voudraient passer outre ces choix auraient tout intérêt à oublier Arduino et à se tourner vers d'autres systèmes de développement plus souples.
Toutes les "découvertes" que tu as rapportées ci-dessus ne sont que les conséquences des choix réalisés par les concepteurs du système Arduino, et je pense qu'il y aurait plus d'intérêt à s'en tenir aux raisons de leur présence qu'à les énumérer en s'étonnant de les voir et à en proposer des alternatives sans savoir ce que cela implique derrière.
Dernière modification par PA5CAL ; 11/10/2014 à 09h32.
Personnellement (C et pas arduino), je me suis toujours bien demandé ce qui pouvait se cacher derrière des foctions comme "DigitalWrite" alors que c'est si simple et évident d'"écrire" un 1 ou un 0 sur une pin ( PORTB=0b00000001; par exemple).
C'est manifestement une liaison série implémentée en soft... C'est d'autant plus malheureux que l' AVR a des modules dédiés pour les liaisons séries type SPI, I2C (TWI) et UART (asychrones).
shiftOut ce n'est que cette merde la????
[CODE
Le max7219 se commande en SPI, donc une programmation "propre" devrait utilser le module AVR dédié
LVPBL
Le 3ème post sur ce forum montre un moyen simple et efficace de piloter les I/O par des macros (et qui peut être transposé à n'importe quel registre du µC).
Il ne reste qu'à faire appel à ce type de macros pour définir une pin en sortie puis la passer à l'état haut par exemple :
Au niveau performances, difficile de faire mieux (une simple écriture dans un registre du µC).Code:configure_as_output (PA0); set_high (PA0);
L'inconvénient est pour la portabilité du code. En cas de changement de famille de µC, il faudra réécrire les macros (ce qui ne serait pas nécessaire en utilisant l'ASF d'atmel, ou le langage arduino, qui gèrent déjà ce genre de chose, au prix d'un code parfois légèrement plus lourd).
Ok merci pour vos réponses
*PA5CAL donc si je comprend bien, au lieu de reproduire une alternative hyper minimaliste à ce qu'on programmé les mecs d'arduino, autant comprendre les tenants et les aboutissant c'est à dire, comme le dit *laveplusblanc et comme je l'ai effectivement pensé en voyant ces deux digitalWrite successifs, implémenter la chose avec les outils dédié c'est à dire spi, etc.
La je dois partir, mais d'ici ce soir je vais aller voir comment on ce sert d'un module dédié pour faire une liaison spi, et puis *PA5CAL, il serait naïf de penser que je n'ai pas le datasheet des ic que j'essaye de comprendre et de l'avr assembleur en permanence dans mon navigateurNon non, j'essaye bel et bien de faire les choses comme il faut, et je suis arrivé sur ce sujet de discussion avec l'idée de comprendre et de me débarrasser définitivement d'un outil qui s'appelle arduino et qui ne répond pas à mon envie de programmer. J'ai également commencé a faire le design d'une petite carte avec cet ic atmel sur fritzing, un petit soft pour dessiner des pcb, alors effectivement si vous arrivez à me faire comprendre que la pin PD0 sert à bien autre chose, je vais aller voir ça plus précisément dans le datasheet pour comprendre la chose et faire différemment.
Le but au final est tout de même de réaliser quelques classes en c qui permettra aux gens de réaliser des choses simples à partir de la même base c'est à dire du même ic, après libre à eux d'adapter pour d'autres ic j'imagine.
*Slan85, je vais aller voir cela, en effet je ne me rappel plus de toute les pages de cette discussion
Quand je disais "ce forum", c'est celui du lien, pas la discussion actuelle (effectivement, ça porte à confusion).
Ce qu'il y a derrière, comme je viens de l'expliquer dans le principe, c'est tout ce qui est nécessaire pour permettre à un débutant d'exploiter les différentes cartes Arduino d'une manière compatible avec les choix de conception de cette gamme de produits.
On peut trouver notamment :
- la vérification de la pertinence de la commande demandée ;
- la sélection des registres et des bits correspondant au numéro de pin de sortie désigné ;
- la configuration des circuits pour préparer l'exécution de la commande, comme l'arrêt d'un éventuel générateur PWM sur cette pin (avr) ou la manipulation des résistances de pull-up (sam) ;
- l'exécution de la commande proprement dite, en veillant à ce qu'aucun déclenchement inopiné de routine d'interruption ne vienne altérer le résultat escompté.
Une seule instruction en assembleur (ou son équivalent en pseudo-C) peut fixer l'état de sortie de la pin comme souhaité, mais c'est alors au développeur de penser à prendre en charge tout le reste dans sa conception, nécessité que le système Arduino se propose précisément de réduire ou d'éliminer compte tenu du public auquel il s'adresse.
Ce bout de code permet surtout de transférer simplement des données à un registre à décalage, de façon synchrone (une interruption restant toujours possible), sans suivre aucun des protocoles cités, et sur n'importe quelles pins ne correspondant pas à des fonctions dédiées utilisées. On y a recours en principe afin de disposer d'une sortie parallèle sur un ou plusieurs octets.
À noter au passage que sur les Arduinos à base d'ATmega328p, les pins SDA et SCL (TWI) sont déjà réservée pour les entrées analogiques A4 et A5. Quant à SCK et MOSI (SPI), qui vont d'ailleurs de paire avec MISO, ils sont utilisés par certains shields Arduino (shield Ethernet, notamment).
Dernière modification par PA5CAL ; 11/10/2014 à 13h40.
Comme tu as dans l'idée de te débarrasser du logiciel Arduino, ce qui est une démarche saine et professionnelle si ton but est de créer tes propres produits, tu en viendras certainement aussi à vouloir te débarrasser également du matériel, dont les choix de conception sont particulièrement handicapants (par exemple, ne pas pouvoir profiter des ports 8 bits présents parce que des fonctions spécifiques ont bêtement été implantées au milieu est plutôt gênant).La je dois partir, mais d'ici ce soir je vais aller voir comment on ce sert d'un module dédié pour faire une liaison spi, et puis *PA5CAL, il serait naïf de penser que je n'ai pas le datasheet des ic que j'essaye de comprendre et de l'avr assembleur en permanence dans mon navigateur
Ta conclusion sera alors, comme je l'ai énoncée, qu'il est préférable de choisir d'emblée un tout autre système de développement qu'Arduino, ce dernier pouvant tout au plus servir de source d'inspiration.
Dans ce cas, choisir Arduino comme point de départ (comme le suggère le sujet de cette discussion) ne paraît pas très pertinent. Le site d'Atmel et les autres communautés utilisant les produits du constructeur seront probablement d'un plus grand secours.
Dernière modification par PA5CAL ; 11/10/2014 à 14h06.
Je pense qu'il y a quand même un intérêt, pour quelqu'un n'ayant pas la possibilité de faire son propre PCB, de passer par de l'arduino.
Effectivement, certains choix de conceptions vont être limitant, mais on peut profiter des nombreux shields Arduino pour étendre les possibilités matérielles de la carte de base, ce qui sera plus compliqué sur une carte de développement classique (sans ajout de fils).
Il vaut peut être mieux dans ce cas se tourner vers la version mega2560, qui propose plusieurs ports 8 bits complets.
@sylvainmahe
Si vous êtes sous linux :
La solution "eclipse" (que vous connaissez sûrement déjà si vous programmez en c/c++) avec :
- Avr-GCC (/GDB)*
- Eclipse C/C++* : http://www.eclipse.org/
- Le plugin AVR: http://avr-eclipse.sourceforge.net/w...Eclipse_Plugin
- ZylinCDT pour la connection hardware: http://opensource.zylin.com/embeddedcdt.html
- Avrdude* (Programmateur)
- AVaRice* (serveur GDB)
* : inclus dans la liste des packages Ubuntu
Ou bien Avrstudio (4.17 ou 4.18) sous Wine (mais restrictions car Wine ne gère pas l'USB)
LVPBL
Oui, et j'en profite moi-même pleinement, par exemple lorsque j'ai des besoins ponctuels (y compris professionnels) auxquels je dois répondre sans attendre.
Mais il existe d'autres cartes que les Arduinos sur le marché, et les Arduinos ne conviennent pas à tous les projets pour lesquels les ressources de leur microcontrôleur s'avèrent pourtant suffisantes.
Certainement.
Mais on en revient alors à utiliser un matériel sur-dimensionné et beaucoup plus cher que nécessaire. Et concernant les shields, leur achat fait souvent passer le prix de l'ensemble au-dessus de celui d'appareils disponibles dans le commerce et proposant des fonctionnalités supérieures.
Or, cette sorte de "gâchis" et ce surcoût doivent se justifier, ce qui n'est pas possible dans tous les cas ni pour tout le monde.
Et puis si une carte Mega 2560 peut pallier certaines limitations d'une carte Uno pour une tâche normalement accessible à un µC ATmega328P, on peut aussi se retrouver bloqué quand il s'agit de pallier les limitations d'une carte Mega 2560 pour une tâche accessible à un µC ATmega2560, les autres produits plus puissants de la gamme Arduino n'offrant pas les mêmes avantages que les AVR.
Arduino cible donc bien des besoins particuliers, et n'est en aucun cas un produit universel. Il est donc normal de voir ses espoirs déçus si l'on n'a pas suffisamment étudié la question : ce n'est alors pas le produit qui est mauvais, mais le choix de celui qui l'a adopté.
Dernière modification par PA5CAL ; 11/10/2014 à 15h36.
Ok *Slan85 effectivement j'ai été voir ton lien et ça semble simple, la méthode à l'air bonne
*laveplusblanc tout à fait je connais bien ses outils la, personnellement je programme tout dans gedit, qui est juste un notepad++ linuxien j'ai envie de dire, j'aime le simple et épuré... Bref, déja je vais commander un petit usbasp et une fois reçu, virer le bootloader de mon arduino nano, pour faire quelques tests en pur c. Je prend ça je pense que c'est bon:
http://www.hobbyking.com/hobbyking/s...occessors.html
C'est un magasin de modélisme et comme j'en fait et que j'ai d'autres pièces à commander ça me semble approprié. Après bien-sur on pourrait concevoir cette petite carte nous même mais on en fini plus.
Pour revenir à un point qui me semble important évoqué par *PA5CAL, c'est vrai que l'atmel 2560 ou même 328p peuvent surement faire des choses bien plus élaboré que disons le bridage de fait imposé par l'équipe arduino sur leur carte et à cause de leur bibliothèque orienté débutant. En revanche, ce qui est différent dans mon cas et le cas de pas mal de gens finalement quand on observe les commentaires, c'est que le petit projet que j'envisage pourrait parfaitement être fait avec une carte arduino et les bibliothèques arduino, car véritablement je n'ai besoin que de passer des pins à 0 ou 5v, lire leur valeur, faire des liaisons séries, peut être un peu de PWM si je souhaite piloter 4 esc d'un quadricopter par exemple (dans un autre projet à venir), donc pour ma part en tout cas, je n'ai besoin que de la base, et franchement, on peut envoyer une fusée saturn 5 dans l'espace avec juste 3 gyros, une lecture des valeurs de 3 pins, et un digitalWrite arduinesque sur 3 autres pins
Je pense que tout dépend des contraintes de chacun, mais ce qui me pousse à vouloir faire ce que je vous ai expliqué c'est finalement uniquement la passion et l'envie de comprendre et de faire les choses soit même.
Bon en tout cas c'est cool avec tout les intervenants on avance bien je trouve.
Bonjour à tous,
Je me permet d'intervenir car le modèle en question serait parfait, car c'est la version 2x3 pins,
s'il y en avait en stock !
Malheureusement seul l’entrepôt en Grande Bretagne a du stock.
Sauf que chez eux .... c'est pas le même, il s'agit là du modèle 2x5 pins nécessitant de massacrer un connecteur 2x5 femelle et "d'un peu croiser des fils".
Comme je suis plutôt hardware (d’où mon intérêt pour l'assembleur), ça ne m'a pas dérangé de faire ça, mais pour un puriste du C, je ne sais pas.
En tout cas merci pour votre intervention car mes propos avaient fait dévier le sujet
.
Sinon il existe des adaptateurs pas très chers: http://www.dx.com/fr/p/10-pin-to-6-p...5#.VDqY5blxnok
