Reprise du message précédent :
dites, je voudrais connecter un arduino sur une carte mère sur les pins de l'activité HDD pour compter les signaux et faire s'allumer une LED qui varie en intensité selon l'activité, plutôt que clignoter (enfin clignoter différemment quoi)

je suis pas une bête en électronique...   je branche le + de la pin LED de la carte mère sur un input de l'arduino et c'est tout? l'arduino sera branché en USB sur un autre ordi, mais les ordis sont reliés à la même prise électrique, donc pas besoin de brancher de masse, si?

edit: quelque chose me dit que je devrais mettre une résistance entre les 2 pins LED de la mobo pour "simuler" une LED, et brancher un câble en plus d'un côté de la résistance (peu importe lequel) vers un input du arduino?

Y'en a icite qui ont déjà utilisé PureData en conjonction avec une Arduino ?
 
Je suis en train de m'y intéresser, et sur les possibilités que ça offre (musicalement parlant en tout cas) c'est…

http://www.instructables.com/
 
La majorité des projets est en anglais, mais certains sont aussi en français ...

Oula À moins de savoir exactement ce qu'on fait il faut toujours brancher la masse. Le courant ne peut circuler qu'en boucle fermée. Après dans le cas présent ça peut fonctionner sans car les masses des ordis sont reliées par la terre, mais c'est pas propre!

Je ne sais pas comment est fait le circuit sur la carte mère, autrement dit si c'est le + ou le - de la LED qui est commandé. Tu peux mesurer avec un multimètre (résistance ou test continuité) entre la broche 'LED -' et une masse pour voir si il y a un contact? Si tel est le cas tu peux simplement brancher le 'LED -' sur la masse arduino et le 'LED +' sur une entrée. Pas besoin de résistance en principe mais cette dernière (genre 1k) peut éviter de la fumée en cas d'erreur... Comme l'arduino est branché sur un autre ordi perso je mettrais un optocoupleur pour ne pas trop mélanger les potentiels, mais ce n'est pas nécessaire (d'autant plus qu'on aura pas d'isolation galvanique réelle car les masses sont reliées par la terre comme je disais - sauf ordi portable peut-être).

edit: Je suppose que la LED est simplement commandée par du 5V avec une résistance, je ne pense pas qu'il y ait une source de courant sur la carte mère pour ça...

Bonjour,
 
Petite question: vous avez déjà utilisé des capteurs gyro et accéléromètre?
l'idée c'est de mettre ca dans une voiture pour logguer les G and co sur circuit.
 
merci

 
merci, je regarde ça prochainement!

ouiiiiiiiiiiiii

j'ai un 9-dof adafruit, celui recommandé ici: https://hackaday.io/project/8952-el [...] eadtracker

le code que le mec a filé fonctionne pas. j'ai refait un truc qui fonctionne, mais pas suffisamment bien pour ce que je veux faire (disons que le 9-dof ne remplacera pas un trackIR). la lib est peu/mal documentée et j'ai galéré un peu pour la calibration mais je m'en suis sorti. je te resors des liens vers des forums adafruit sous peu où j'avais posté mes problèmes, et mes solutions

et bim! https://forums.adafruit.com/viewtop [...] 31&t=92641

dis-moi si tu as des questions! je suis vraiment pas spécialiste mais je peux peut-être t'aider

Sinon pour tester vous pouvez toujours prendre un adaptateur wii nunchuk, y a les capteurs embarqués de gyro et accéléromètres dans cette petite manette.

Faudrait que je teste çà a l'occasion sur la moto d'ailleurs ...  

http://forum.arduino.cc/index.php?topic=43106.0

http://hacknmod.com/hack/how-to-ch [...] -nunchuck/

J'ai un pote qui veut que je lui fasse un système de commande des volets roulants de sa future baraque (par appli smartphone si possible). Je crois que certains ici ont déjà fait ça, non ? Vous pourriez me guider un peu sur les choix à faire ?

Vu que les heures de lever et coucher du soleil sont connues, il a qu'à mettre une programmation horaire et basta

Si jamais il n'y a pas de continuité entre la broche 'LED -' et la masse on a à faire à une commande en open-collector. Dans ce cas: Relier la masse de l'arduino avec la masse de la carte mère (ou de l'alim qui alimente cette dernière, genre se brancher sur un connecteur Molex). Mettre une résistance (quelque kOhm je dirais) entre 'LED -' et 'LED +' et brancher l'entrée arduino sur 'LED -'. Attention le signal sera inversé, LED allumée = '0' sur l'entrée arduino.

Si la masse est continue et c'est bien le 'LED +' qui est commandé il y a toujours un risque (que j'estime faible mais bon) que la carte mère sorte plus de 5V. On peut régler ça avec une résistance série (recommandée de toute façon histoire d'éviter la fumée en cas d'erreur) entre la carte mère et l'arduino et une diode Z 4,7V entre l'entrée arduino et la masse.
edit: Même en cas de commande open-collector le problème peut-être présent, la solution est identique: diode Z.

 
Salut,
 
Merci pour la proposition
Je suis parti sur un MPU6050 et je verrais si j'arrive à le faire fonctionner ^^

 
Mysensors  

Merci pour le lien, j'ai regardé, effectivement ça pourrait servir  
 
Mais mes questions étaient plus de l'ordre de "comment relier l'Arduino aux volets ?" ou "comment vous alimentez l'Arduino si elle est positionnée dans le boîtier de l'interrupteur du volet ?", etc

Hello
 
J'aimerais avoir quelques conseils pour essayer de m'améliorer en code.
 
Je dois remplacer une télécommande 433Mhz, j'ai capturé le signal qui est tout bete et j'arrive à le transmettre grace à mon arduino et un module d'emission 433Mhz.
 
Mon code est ci-dessous. La télécommande fonctionne à 800Hz et le signal se compose de 66 bits.
J'ai donc renseigné mes 66 bits dans un tableau que je parcours ensuite toutes les 650 microsecondes. Je renvois le signal 6 fois avec un interval de 16 millisecondes.
 
est-ce qu'il existe une méthode plus propre ou plus optimisée pour faire la même chose ?
 
(je vous ai mis que la fonction intéressante et la définition du tableau)

 
merci de vos avis

erreur! Un tableau de 66 valeurs a des indexes allant de 0 à 65, il faut donc tester i<66. Sauf que ton tableau ne contient que 64 valeurs... Les deux dernières seront donc à 0. À part cela, si c'est constant autant le déclarer ainsi: const boolean

Optimisée au niveau utilisation de la mémoire ou du temps de calcul?

Pour la mémoire: D'après la doc Arduino:  (Each boolean variable occupies one byte of memory.) == gros gaspillage. On pourrait utiliser un tableau de unsigned char/int/long pour économiser de la place mais il faudra décoder en temps réel (avec du bitshift et du ET binaire). Si la place n'est pas un soucis on peut laisser comme ça, c'est plus simple...

Au niveau temps de calcul: On a des délais mais bien faibles (650µs et 16ms), du coup je ne pense pas que ça vaut la peine de sortir un timer et une interruption, surtout sur du Arduino.

 
Ah oui exact, merci pour la correction. J'avoue avoir fait ce code un peu à l'arrache
 

 
J'y ai pensé au tableau de int avec décodage, mais j'ai peur de ne pas tenir dans les 650µs lors de la lecture.
En tout cas rien de flagrant pour mon code, je vais continuer comme ca.
 
Merci pour ton avis

C'est vraiment 66? Comme je disais dans ton initialisation il n'y a que 64 bits ce qui donnerait 8 octets tout rond.
 

Ca ne devrait pas être un problème.

Le décalage de bit ça doit être une des opérations les plus rapides à effectuer pour un processeur.

Il faut différencier: Un décalage d'une position sur AVR c'est un cycle (sur un registre 8 bit). Par contre si on veut décaler d'un nombre n le compilateur doit fabriquer une boucle car les AVR ne possèdent pas de https://fr.wikipedia.org/wiki/Barrel_shifter (à ma connaissance). Ceci étant en 650µs on a largement le temps. Les AVR sont d'architecture RISC, toutes les opérations (élémentaires bien sûr) sont "rapides" = 1-4(5?) cycles d'horloge.

Merci pour la précision, effectivement je parlais pour un proc PC en pensant que c'était sans doute pareil pour un AVR

Vu la vitesse de l'engin doit y avoir moyen de faire le décodage en moins de 5µs en codant en assembleur

selon la vitesse (c'est quelle fréquence d'horloge les Arduino?) et le compilateur même avec du C en moins de 5µs - essayer et voir.

Un arduino ça tourne à 16MHz, un AVR 8 bit ça te torche la majorité des instructions simples en un coup d'horloge soit 0,0625µs et un branchement prends maxi 3 coups d'horloge.
 
Vais essayer, ça fait longtemps que j'ai pas fait d'assembleur RISC  

Bon donc j'ai compilé ce code (pas testé en vrai ) :
 

 
J'ai décodé l'assembleur généré derrière, à la grosse entre deux "digitalWrite" j'ai maxi 23 coups d'horloge en dehors du temps perdu par le "digitalWrite" (suis pas allé voir ce qu'il y a derrière, c'est potentiellement mal branlé), soit 1.44µs.
 
L'assembleur généré est globalement optimisé. Par exemple le compilateur décide de remplacer la boucle sur i par une boucle sur le pointeur data_ptr, ce qui lui permet de:
-bénéficier d'une instruction (ld Rd, Y+) qui fait dat = *data_ptr et data_ptr++ en même temps et en deux coups d'horloge
-économiser un registre pour stocker i en faisant for(data_ptr=data;data_ptr<data+sizeof(data);++i)
 
 

Impressionnant.. j'ai encore beaucoup à apprendre. Et merci pour l'exemple, c'est intéressant à décortiquer

Bonjour,
 
J’aimerai savoir comment réaliser le programme suivant avec des delay real et non entier.
 
#define led 2  
 
void setup()  
{                
  pinMode(led, OUTPUT);    
   
}
void loop()  
{
   
  digitalWrite(led, HIGH);  
  delay(400.43);                
  digitalWrite(led, LOW);    
  delay(400.43);                
}
 
Par avance, merci pour votre aide.
 

Au passage l'assembleur du loop décortiqué:

 
en 1° colonne j'ai mis le nombre de cycles d'horloge (les branchements prennent plus de temps s'ils changent le cours du programme).
 
D'ailleurs j'ai merdé, en choisissant un int pour j ça fait perdre deux coups d'horloge

DigitalWrite est un peu lent, me semble que ça vérifie pas mal de choses style input/output avant de basculer. Une bonne grosse écriture sur le port en mode brutal est clairement plus rapide.

  Tu as compilé ça dans l'environnement Arduino ou directement avec avr-gcc? Si 1) comment tu fais pour sortir les fichiers debug (listing que tu as posté)? C'est quoi le réglage au niveau optimisation, speed (O3) ou taille (Os)?
 

Ça c'est sûr, au mieux une instruction (sbi). Pour digitalWrite il y a des machins plus rapides qui profitent du language C++, faut regarder sur le net.

 
Avec avr-gcc.
La méthode:

• Lancer la compilation dans l'environnement arduino en ayant choisi l'option "afficher les résultats détaillés" qui affiche toutes les commandes effectuées
• Copier le contenu de la petite fenêtre en bas vers un éditeur de texte
• Rechercher la ligne qui concerne le fichier qui nous intéresse
• La bricoler (voir exemple ci dessous*) pour rajouter l'option -S qui sort de l'assembleur et adapter le chemin
• Lancer une fenêtre de commande dans le dossier de l'IDE arduino
• Lancer la commade et récupérer le résultat la ou il tombe (dossier temporaire)

On voit d'ailleurs que c'est optimisé pour la taille du coup
 
 
*:

devient

par exemple

Tu pourrais utiliser DelayMicroseconds, sauf que la valeur max c'est 16383. Une solution serait de combiner les deux fonctions: delay(400); delayMicroseconds(430);
Sauf que ça ne sera jamais exact, à cause des délais causés par les appels des fonctions et d'éventuelles interruptions (même si tu en utilise pas je suppose qu'il doit y avoir un timer qui tourne par défaut en arrière-plan). En même temps pour une LED je ne vois pas l'intérêt d'un délai si précis, tu veux faire quoi?
 

Merci pour l'info!
 

Ça serait intéressant de voir si -O3 change quelque chose (et avec quelle intensité).
 
Ce qui me plaît pas par contre c'est que je ne vois pas de -Wall dans la ligne de commande, pourquoi les gars qui fabriquent l'environnement Arduino ne mettent pas ça par défaut? (On peut l'activer manuellement il me semble.)

ok merci,
 
je vais regarder avec la fonction millis() et micros()

Sans optimisation c'est comme attendu un massacre (stockage/destockage systématique sur la pile). Exemple pour un bête i++:

 
Avec O3 c'est kiff kiff dans ce cas particulier et le temps d’exécution semble proche:

Bonjour,
Petite question à ceux qui connaissent bien la gamme Arduino (et compatible) : je vois sur la site officiel que la Nano part à la retraite :
https://www.arduino.cc/en/Main/ArduinoBoardNano

Je trouve le format pratique pour des tous petits projets pas chers et j'ai des projets qui s'en servent, pinout et empreinte exactes compris.
Le seul truc vraiment obsolète c'est le connecteur miniusb.
-> Il y a une nouvelle carte sensée reprendre le même format ou c'est cuit ? Je vais en racheter quelques unes tant qu'on la trouve encore .
Merci

Il part à la retraite par le producteur officielle mais les versions alternatives et notamment les copies chinoises seront encore dispo, non ?
A ta place, je m'en prendrai une cargaison.

Copies effectivement, sinon t'as la micro qui reste proche.

Au pire, il devrait toujours rester des clones compatibles

Edit :  

 
1€ plus cher la micro que la nano, mais surement plus pratique avec le micro usb

Et support direct de l'USB donc ça laisse le port série dispo  

La micro est celle que je cherchais, merci. A mon avis c'est le meilleur successeur naturel au nano.  
Pour les clones effectivement on en trouve encore tout plein, aucun souci de ce côté là.