Show Posts
Pages: [1] 2 3 ... 155
1  International / Français / Re: Equivalent digitalRead on: Today at 10:35:44 am
Eeeeeeeeuh............ tu peux en dire plus.
Parce que  gain ,taux d'harmoniques,  fréquence de transition, cela me parle clair mais là  c'est un peu flou.
2  International / Français / Re: Equivalent digitalRead on: Today at 08:51:51 am
Etape 2

Quel remplaçant pour digitalRead ?

Il y a bien sûr la manipulation des registres, la solution est imbattable mais on est obligé de coder "en dur", exit la facilité de désigner n'importe quelle pin.

Il y a la solution digitalReadFast mais je n'ai eu que des problèmes avec :
1) il existe plusieurs versions que rien ne différencie. J'ai eu du mal à en trouver une qui compile avec gcc 4.8.
 https://github.com/watterott/Arduino-Libs
2) utilisée dans un seul fichier cela fonctionne mais avec plusieurs fichiers je n'ai pas compris.

Et il y a une solution dont je voudrais vous parler et qui m'interpelle : je ne suis pas sur de bien l'avoir compris.

En faisant des recherches je suis tombé sur un certain blog d'un certain Skywodd qui traitait du sujet et qui avant moi (2013) émettait des gros doutes sur la compatibilité de digitalRead avec le capteur DHT11. Encore une fois Sky si je t'avais lu avant les autres j'aurais gagné du temps ! Mais comme on dit mieux vaut tard que jamais.

En résumé notre ami Skywodd a retenu l'essentiel de la gestion arduino pin → PORT et a supprimé tout le superflu.

J'ai voulu m'en inspirer pour créer mes propres fonctions  cela fonctionne mais les mesures que j'ai fait ne montrent pas un gain considérable.

Mon instrument de mesure :
le fichier asm et …. NON l'assembleur je n'y connais RIEN.
Mais par contre j'ai des timers.  Sur un 328p j'ai pris un timer 8bits puisque j'ai un micro 8 bits, le T2 parce que le T0 sert déjà a trop de chose.
J'ai réglé le préscaler à 1 (TCCR2B= 1) comme cela un incrément sur le compteur correspond à 1 cycle horloge (j'espère que ce n'est pas 2 → avec la logique synchrone il subsiste un doute).
Pour éviter à avoir à gérer les débordements de compteur comme le fait milllis() je fait systématiquement une raz du compteur TCNT2 avant toute utilisation.

En comparant digitalRead, les fonction inspirées du travail de Skywodd et l'action directe sur les registres j'obtiens les résultats suivant :
Test de rapidité d’accès aux E/S
|Opération       |Nbre Cycles  horloge|
|                           |  Ard   |Rapide|  Reg  |
|Ecriture 0       |  83      | 54       |  3      |
|Ecriture 1        |  81       | 54       |  3      |
|Lecture  0      |  64      | 48       |  2     |
|Lecture  1      |  62        | 48       |  2     |

Je trouve le gain un peu faible.

Me suis-je planté dans mon instrument de mesure ?
Me suis je planté dans mon code ?
3  International / Français / Equivalent digitalRead on: Today at 08:50:17 am
Bonjour,

Etape 1:
Je suis toujours avec mon capteur AM2302(DHT22). Toutes les différentes bibliothèques présentent les mêmes défauts. Les utilisateurs se plaignent de trop d'erreurs de somme de contrôle ou de TIMEOUT dépassé.

Certes au début la seule version de la datasheet était en chinois  smiley-surprise ce qui ne simplifiait pas le travail. Maintenant une datasheet officielle existe en anglais mais l'architecture de la bibliothèque reste le même.

Ce que je reproche :
1) attente de réponse du capteur après le relâchement : la data sheet nous dit que le capteur réagit en moyenne au bout de 20µs <Tgo <200µs.
La sortie du capteur est un collecteur ouvert chargé par 5k ce qui s'appelle aussi un montage émetteur commun. Au repos la sortie n'est pas activée donc on a un état permanent 5V soit 1Logique.
La librairie impose une pause fixe de 40 µs. Ce qui fait que si le capteur a un temps de réponse de 100µs il est dans la spec et on va droit dans une erreur TIMEOUT dans la réception du premier élément binaire  d'acquiescement (0L).
La solution : utiliser une boucle while (etat haut) { // ne rien faire }  Dès que le capteur enverra son premier élément binaire d'asquiessement, un 0L, on sortira de la boucle et on entrera dans la boucle de détection du 0L.

2) On arrive au point faible : le temps de réponse d'un digitalRead.
Les temps des éléments binaire 0L et 1L sont les suivants :
Acquiescement : 0L et 1L = 80 µs (soit 1280 cycles horloge)
Bit 1L : élément binaire 0L = 50 µs soit 800 cycles horloge
              élément binaire 1L = 70 µs soit 1120 cycles horloge.
Bit 0L :élément binaire 0L = 50 µs soit 800 cycles horloge
              élément binaire 1L = 26 µs soit 416 cycles horloge.

On voit de suite que la détection d'un élément binaire 1L court va être délicate avec un digitalRead.
Il ne faut pas oublier que le micro et le capteur ne sont pas synchrone et qu'il est toujours possible de rater un début de détection. On a donc intérêt a ce que la boucle soit le plus véloce possible.

3) Utilisation de la fonction millis() pour déterminer si l'élément binaire 1L est court ou long.
Millis() comme toutes les fonctions arduino est prévue pour être simple d'emploi, il ne faut pas en plus lui demander d'être optimisée.
Qu'a -ton besoin exactement : on se fiche de la mesure exacte en µs, on a juste besoin d'avoir une image des longueurs respectives de l'élément binaire 0L et du 1L qui le suit.
Cette image on l'a déjà dans le code :
Code:
loopCnt = DHTLIB_TIMEOUT;
    while(digitalRead(pin) == HIGH)
    {
        if (--loopCnt == 0) return DHTLIB_ERROR_TIMEOUT;
    }
Si on déclare deux variables loop ;
uint8_t loopCnt_0  et uint8_t loopCnt_1

et qu'on transforme très légèrement le code précédent:
Code:
loopCnt_0 = 0;
    while(digitalRead(pin) == HIGH)
    {
        if (loopCnt_0++ == DHTLIB_TIMEOUT)  return DHTLIB_ERROR_TIMEOUT;
    }
Il suffira de comparer si  loopCnt_1 > loppCnt_0 --> on a affaire à un bit 1L sinon c'est un bit 0L.
Cette solution permet de faire gagner un temps non négligeable.

Etape 2 digitalRead et autre:  Message suivant
4  International / Français / Re: Emplacement de la déclation des variables on: September 28, 2014, 01:48:03 pm
Je crois surtout que je n'arrive pas à exprimer clairement ce que je sens.

Prenons un exemple : la gestion des capteur DHxx.
Cet exemple n'est pas pris au hasard, je suis dessus et  je ressens que la classe a été écrite par un "softeux" et non pas un "hardeux" comme disent les djeuns d'où ma préoccupation de "hardeux" sur l'adéquation  vitesse du code/vitesse de réponse du matériel.

Extrait du fichier dht.h
Code:
class dht
{
public:
    // return values:
    // DHTLIB_OK
    // DHTLIB_ERROR_CHECKSUM
    // DHTLIB_ERROR_TIMEOUT
    int read11(uint8_t pin);
    int read(uint8_t pin);

    inline int read21(uint8_t pin) { return read(pin); };
    inline int read22(uint8_t pin) { return read(pin); };
    inline int read33(uint8_t pin) { return read(pin); };
    inline int read44(uint8_t pin) { return read(pin); };

    double humidity;
    double temperature;

private:
    uint8_t bits[5];  // buffer to receive data
    int _readSensor(uint8_t pin, uint8_t wakeupDelay);
};

Question d'après toi quel statut ont les variables publiques humidity et temperature ?

Et quel statut aurait une variable déclarée dans la partie private par rapport à la méthode private readSensor?
5  International / Français / Re: Emplacement de la déclation des variables on: September 28, 2014, 12:37:13 pm
Je reprend :
Voila ce que j'ai compris : on a une classe donc deux fichiers  "classe.h" et "classe.cpp", plus un fichier "utilisation.cpp" qui utilise la classe.

Variables définies dans le fichier "classe.h"
- Variables Publiques :
Elles se comportent comme des variables globales dans le fichier utilisation.cpp, ou bien ce comportement est limité au seul temps d'accès ?

- Variables Privées
Si elles sont déclarées dans le fichier classe.h, elles peuvent être utilisées directement par plusieurs méthodes privées donc elles ont le statut de variables globales limité à l'espace de la classe.cpp. Et donc un temps d'accès de variables globale.
6  International / Français / Re: Problème avec un Atmega 328 on: September 28, 2014, 12:22:22 pm
Quote
Donc j'ai rien dit,
Ca tombe bien si tu n'a rien dis, on a rien entendu  smiley-mr-green
7  International / Français / Re: Emplacement de la déclation des variables on: September 28, 2014, 12:16:55 pm
Le pire c'est que ce document j'ai du le lire plusieurs fois ........

Que l'accès à une  globale soit plus lent je le conçois.

Ce que je n'avais pas vu, et c'est sans doute du à mon manque d'habitude de la programmation objet, c'est que les variables définies dans le fichier.h sont des globales pour les variables définies publiques  mais aussi que celle qui sont définies privées mais en dehors des méthodes qui les utilisent sont globales en interne à la classe  (vrai/faux ?). Mais effectivement cela n'a rien d'illogique.
8  International / Français / Re: Problème avec un Atmega 328 on: September 28, 2014, 11:42:37 am
Quote
alors qu'un vrai ATmega de chez ATmel sans bootloader est à 4€ par 1000pc
Il faut revoit tes prix :
Origine Mouser.com (USA) , prix communiqué en €  sans FDP ni TVA
ATMEGA328p CMS
- par 1 = 2,59 €
- par 10 = 1,47 €
ATMEGA328P PDIP
- par 1 = 3,12€
- par 10 = 1,77 €

Je ne te dit pas les prix par cartons de 1000 avec prévision de commande de 10 000 annuel !
C'est aussi pour cela que les cartes UNO ou Mega qu'on trouve sur Ebay sont si peu chères. Imagine un façonnier qui se spécialise dans  ce domaine et qui achète 100 000 pièces/an. Surtout que comme tu l'as dit les frais de transport il n'y en a pas trop c'est fabriqué en Chine ou Singapoure ou Taïwan ou Macao (bon c'est la Chine maintenant).
9  International / Français / Re: Problème avec un Atmega 328 on: September 28, 2014, 10:36:17 am
Des faux Atmel ou des Atmel déclassés mis à la vente j'ai beaucoup de mal à y croire.  ATmel aurait  trop à y perdre en réputation.

Par contre des micros, bons en sortie ATmel, mais mal manipulés et/ou bootloader arduino injecté à la va vite et sans contrôle, cela oui c'est fort possible chez certains fournisseur et à moins de 2,9$ (2,2 €) bootloader compris effectivement on peut se poser des questions.
Mais au prix où il les a payé c'est un risque acceptable sauf si c'est la conséquence de mauvaise manipulations, décharges électrostatiques par exemple, et que pour les autres pièces les défauts peuvent, ou ne peuvent pas, se manifester plus tard .
Tout dépend de la destination finale du matériel : sécurité ou loisir.
10  International / Français / Re: Séquence euclidienne simple on: September 26, 2014, 10:43:29 am
Peut-être que c'est moi qui suis bouché ( ce qui est fort possible ) mais je n'ai absolument rien compris.

J'ai vérifié le terme "division euclidiene" et wikipédia me donne :
Quote
En mathématiques, et plus précisément en arithmétique, la division euclidienne ou division entière est une opération qui, à deux entiers naturels appelés dividende et diviseur, associe deux autres entiers appelés quotient et reste.
Donc 35 div 4 donne : quotient = 8 et reste = 3   parce que 35 = 8*4 + 3
Cerise sur le gâteau  ton texte est truffé d'anglicismes que je connais mais je ne suis absolument pas certain qu'on leur donne la même signification.
Actuellement je ne vois que des "initiés"  qui peuvent être en mesure de te répondre .
Mais peut être que si tu expliques clairement ce que tes modules doivent faire .................
11  International / Français / Re: Emplacement de la déclation des variables on: September 25, 2014, 11:01:44 am
Et bien merci.

A noter que j'avais simplifié ma présentation au maximum.
En fait au début j'avais :
- 1 fichier *.ino
- 1 librairie avec ses fichiers *.h et *.cpp

La dégradation s'est manifesté dès que que j'ai voulu rendre la variable "boucle" publique pour l'exploiter simplement à partir du fichier *.ino
Et cette façon de procéder je l'ai rencontré plusieurs fois, c'est donc à éviter.
La parade que j'ai trouvé est de laisser "boucle" défini dans sa fonction et d'utiliser une variable intermédiaire(publique) à laquelle j'affectais la valeur finale de "boucle" pour la gestion à partir du fichier *.ino
12  International / Français / Emplacement de la déclation des variables on: September 25, 2014, 10:38:28 am
Bonjour,
Je viens de faire une manip à la c*n dont le résultat m'a surpris.

Le décors : IDE Ard 1.05 Linux.
Dans le répertoire du croquis :
- 1 fichier *.ino
- 1 fichier *.h
Je  cherche à obtenir  une image  du temps d'exécution d'une boucle (While + traitement de la condition).
Dans un premier temps la variable boucle est déclarée à l'intérieur de la fonction machin définie dans le fichier *.ino
Code:
void machin()
{
   uint8_t boucle = 0  ;
   While (condition)  {  boucle++; }
   /-* Traitement de la variable  boucle*/
}
J'obtiens pour boucle une valeur autour de 200.  Pour moi cette valeur dépend principalement du temps de traitement dans  (condition) . "boucle++" ne devant prendre qu'un seul cycle horloge.

Si je déplace la déclaration de la variable boucle en dehors de la fonction c'est à dire dans le fichier *.h elle devient globale (enfin c'est ce que je pense) et la valeur de boucle est grossièrement divisée par deux. Ce qui laisse à penser que l'accès à une variable globale est plus lent que celui à une variable locale. Il doit y avoir une explication mais laquelle ?
13  International / Français / Re: Projet BTS Système Electronique banc de test on: September 25, 2014, 09:48:02 am
Si le premier courant à mesurer est alternatif et non pas continu cela change la donne.

Dans ce cas de figure la solution de @Batto revient à la surface. Reste à vérifier que la sensibilité du composant convient à ton application.

Puisque c'est du service après-vente des statistiques doivent être disponibles concernant les produits sans ou avec problème d'alim.
 Je pense que c'est par là qui faut commencer par regarder pour dimensionner le capteur.
14  International / Le bar / Re: STM32 Comment cela se programme ? on: September 25, 2014, 08:39:26 am
Et nous finissons par nous rejoindre : c'est cette communauté, surtout francophone, qui manque cruellement au projet Mbed.
15  International / Français / Re: Lire la fréquence d'un signal sinusoidale avec la carte Arduino on: September 25, 2014, 08:37:22 am
Des solutions existent mais il faudrait fréq min , fréq max , niveaux crête à crête min et max.

Et aussi "une idée" de la précision de mesure demandée.
Pages: [1] 2 3 ... 155