La gestion des cantons par Arduino !!

Bonjour Dominique et Michael,

Après un parcours en diagonale de la datasheet, il me semble que le 74HC259 pourrait être utilisé pour démultiplexer des sorties PWM.

Les latches en sortie mémorisent la dernière valeur jusqu'au prochain changement. Le programme boucle suffisamment rapidement par rapport à la fréquence PWM pour décider de la valeur de chaque sortie en fonction du cycle PWM de chacune. C'est donc uniquement par programmation que ce circuit pourra produire du PWM.

Bravo pour l'application Androïd. Avec quel environnement / langage est-ce développé ?

Bon dimanche.

La PWM n'est qu'une suite de 0 et de 1 !!

Voilà comment je pense l'utiliser pour les PWM cantons :

L'entrée D (envoi de données) sera toujours à 1.
Je garde mon interruption dans le programme toutes les 128µs. Dans celle-ci, un compteur qui ira de 0 à 78 (pour avoir ainsi du 100Hz)(voir calcul plus haut dans le fil).
Imaginons qu'une loco ait une consigne de 35 sur le canton 2, lorsque le compteur arrivera à 43 (78-35), je placerai la sortie N°2 du 74HC259 à 1. Puis, lorsque le compteur arrivera à 78, je remets toutes les sorties à 0, en basculant l'entrée MR (mémoire) à 0. Le compteur est initialisé à 0 également, et on repart pour un tour...
Quand la loco arrivera sur le canton 3, ce n'est plus la sortie 2 mais la sortie 3 que je passerai à 1.

J'essayerai de faire un petit chronogramme pour mieux expliquer !!

Comme le dit Savigny, c'est le programme qui continuera à générer la PWM, elle sera appliquée sur le 259, mais j'aurai beaucoup moins de sorties digitales à écrire à chaque changement d'état !!!

En ce moment, j'utilise bien le 74HC595 pour faire du PWM, et ça marche... Donc, ça doit fonctionner aussi avec le 74HC259 !!

Pour l'application Android, j'ai utilisé "APP INVENTOR" directement "en ligne" et c'est assez simple à prendre en main !!!
Merci pour le compliment...

Voici un petit schéma pour expliquer comment je vais procéder. J'ai pris l'exemple avec 2 locos qui auraient 2 consignes différentes.
J'espère que vous comprendrez, sinon, posez vos questions, j'essayerai d'y répondre le plus clairement possible !!!



Sinon, en attendant l'arrivée des petits composants en question, j'améliore l'application Android en lui mettant un 2ème écran, sur lequel, nous pourrons suivre le positionnement des trains (comme sur le TCO) en temps réel !! (Et malgré tous les forums dédiés où il paraissait impossible d'avoir la même connexion Bluetooth sur 2 écrans différents, j'y suis arrivé )
Une vidéo, pour vous montrer, sera faite demain soir ou mardi matin...

Ben, ton diagramme ne m'éclaire pas du tout...
Je pense néanmoins avoir pigé l'idée, tu me diras si c'est à peu près ça ou si je suis à coté de la plaque : Le temps d'un tour complet de scrutation étant plus court que le plus petit créneau PWM possible, l'Arduino écrit à chaque tour dans les registres 74HC259 ce qui doit changer sortie PWM par sortie PWM et laisse le reste au statu quo.

Non Dominique, justement, comme le temps de scrutation du programme est trop long, je passe par une interruption toutes les 128µs qui va incrémenter un compteur. Si le compteur correspond à la consigne PWM alors je change la sortie correspondante uniquement. Puis lorsque le compteur est ré-initialisé (en atteignant 78), je repasse toutes les sorties à 0 grâce à l'entrée "MR" du composant qui reset les sorties...
C'est ce que je disais dans le message d'hier à 10h50. Je ne peux pas mieux l'expliquer, désolé!

Merci Michael pour ces explications.

Je n'avais pas tout de suite compris pourquoi tu commences la PWM à l'état 0 et le calcul de la durée à l'état 1. Est-ce bien pour pouvoir tout réinitialiser en une fois avec l'entrée /MR ?

La datasheet du 74HC259 mentionne que l'on peut facilement étendre la capacité avec plusieurs registres, mais je n'ai pas trouvé plus d'indication. Après réflexion, je suppose que cela pourrait se faire comme suit:

• 3 sorties du processeur correpondent aux 3 lignes d'adresse de tous les 74HC259.
  
• 1 sortie du processeur correspond au /MR de tous les 74HC259.
  
• 1 sortie du processeur correspond à chaque /LE de chaque 74HC259.
  

Avec un seul 74HC259, l'économie en sorties n'est pas flagrante vu qu'il faut déjà 5 sorties du processeur pour 8 sorties du 74HC259. Par contre, chaque 74HC259 supplémentaire ne nécessite qu'une sortie supplémentaire du processeur pour sa broche /LE. Ainsi pour n * 8 sorties, il suffit de 4 + n sorties du processeur, n étant le nombre de 74HC259.

Tout juste !! Et je pense que la sortie LE n'est pas nécessaire puisque elle pourra être tout le temps a 1. Pour remettre à zéro on utilise la mémoire MR...

Hello Michael,

Je ne suis pas si sûr que la sortie /LE puisse être tout le temps à 1. Elle doit passer à 0, le temps de mémoriser l'entrée D dans la sortie correspondant à l'adresse choisie.

La datasheet mentionne les modes de fonctionnement suivants.



Pour ton application, tu utiliseras très probablement:

• addressable latch: pour mettre à 1 l'une des sorties;
  
• memory: après la mise à 1 de l'une des sorties, c'est l'état par défaut;
  
• reset: le reset lorsque le compteur atteint 78.
  

Les étapes pour mettre une sortie à 1 sont, avec /MR = 1 et D = 1:

1. Positionner les 3 bits d'adresse.
   
2. Passer /LE à 0.
   
3. Passer /LE à 1.
   

Le mode active HIGH 8-channel demultiplexer n'est pas utile dans ton cas.

Oui pardon je voulais parler de l'entrée D. Elle peut rester à 1. L'entrée LE sera commandée par un 74hc138 pour choisir 1 parmi les 8 74hc259...

nicozea57 a écrit:

La fonction "digitalWrite" sur Arduino prend 5µs chacune, j'utilise donc 270µs pour changer la couleur d'un seul feu !! Je vous laisse imaginer le temps nécessaire si le réseau compte 20 ou 40 cantons !!!!

Je vois que tu commence à t'intéresser à la durée d'exécution des fonctions de la librairie Arduino !

Si tu ajoute à ta compilation l'option qui permet de conserver le fichier assembleur intermédiaire (je crois que c'est -S) tu te rendras compte de la taille de la fonction digitalWrite et donc de sa durée.

Les librairies Arduino sont écrites pour faire de l'initiation et comportent plein de contrôle et de facilités. Le numéro de pin est normalisé pour ne pas avoir à utiliser un numéro de port et un numéro de bit.

L'atméga 328 présent sur les cartes Arduino tourne à 16MHz ( soit 62.5ns par cycle ) et chaque instruction ne prend que 1 ou 2 cycles. Pour modifier un bit d'un port de sortie il ne faut que quelques instructions machines. En conséquence tu peux largement accélérer tes commandes.
Exemple:
PORTB |= _BV(PB1);
positionne à 1 le bit 1 du port B de l'AVR328.
est équivalent à digitalWrite(9,HIGH) ;
mais va beaucoup plus vite.

Ca a l'air intéressant, j'ai regardé, mais c'est un vrai charabia !!!!!
J'ai tenté le coup mais, je n'ai plus rien qui fonctionne correctement sur l'allumage...
Tu as déjà appliquer cela sur un envoi de données vers un 74HC595 ?????

Ce que dit CleoN est très vrai et permet de gagner beaucoup de temps d'exécution, mais quand tu communiques avec un autre composant il faut veiller à ne pas lui communiquer les données trop vite, sinon effectivement ta communication ne marchera plus. Regarde dans les datasheets du 595

Bonsoir Michael,

Ce n'est pas beaucoup plus compliqué que digitalWrite et pinMode. Il faut commencer par écrire les bits qui vont bien dans les registres DDRB et PORTB pour effectuer la configuration de la broche avant de pouvoir y écrire quelque chose. C'est aussi valable pour les autres registres de l'Atmega168 DDRC, PORTC, DDRD, PORTD.

Une très bonne description se trouve à cette adresse: https://www.zigobot.ch/fr/fiches-pratiques-3/45-introduction-aux-microcontroleur/97-les-entrees-sorties-des-microcontroleurs.html.

Bonne soirée.

Oui, oui, j'ai bien tout compris, j'ai même essayé en mettant un délai d'1 micro seconde entre chaque écriture de "bit" mais il ne m'affiche pas du tout ce qu'il devrait. On dirait que c'est décalé ! en index de sortie et en temps aussi... C'est bizarre, pourtant j'ai bien tout vérifié, les ordres sont les bons....
Je ré-essaye...

J'ai trouvé une erreur : inversion de 2 pins sur le PORT C !!!
Mais, maintenant, quand je compile et que j'envoie le programme, j'ai des morceaux du programme qui ne fonctionnent plus ! L'affichage se fait à moitié, certains boutons du pupitre ne répondent plus...

Utiliser ces commandes sur une partie seulement d'un ensemble de 8 sorties influence-t-il les autres?
Mais, de toute façon, même en utilisant les commandes par bluetooth, ca ne fonctionne plus à 100%...

Après vérification, certaines entrées en "digitalRead()" ne fonctionnent plus en mettant les 3 sorties de l'arduino qui vont vers un 74HC595, en méthode écriture directe sur port !! Et elles ne sont pas sur le même port !! Et je n'ai pas modifié les pinMode qui sont dans le SetUp !
C'est louche.....
La partie concernée fonctionne très bien, mais ceux sont d'autres parties du programme qui ne répondent plus...et cela de manière incompréhensible...

Dans le détail, j'utilise PA6, PC5 et PC7 pour commander mon 74HC595. Voici les entrées qui ne fonctionnent plus (ou pas bien) : PC6, PG0, PG1, PL7, PL6, PL5, PL4 !

Question aux arduinotes : J'ai donc utilisé l'écriture direct sur les registres de port de l'arduino. J'écris sur les portC5 et C7 en utilisant bien les logiques OU et ET pour ne pas toucher les autres bits.
Et bien, c'est mon entrée 31 (configurée en input_pullup) qui reste toujours à 0 !! (elle correspond au port PC6) POURQUOI ???
Ce que je traduis par : en écrivant sur PC5 et PC7, je modifie la valeur de PC6 (même en utilisant les OU/ET pour ne pas modifier les autres....)

Code:

//Ecriture à 0 de PC7
PORTC = PORTC & B0111111;
for(int k = NbCantons*4 - 1; k >=  0; k--){
   //Ecriture à 0 de PC5
   PORTC = PORTC & B11011111;
   if(registersK[k]==HIGH){
      //Ecriture à 1 de PA6
      PORTA = PORTA | B01000000;
    }else{
      //Ecriture à 0 de PA6
      PORTA = PORTA & B10111111;
    }
   //Ecriture à 1 de PC5
   PORTC = PORTC | B00100000;
}
//Ecriture à 1 de PC7
PORTC = PORTC | B10000000;

Attention !

PORTC = PORTC & B0111111;

Il n'y a que 7 bits dans ton octet écrit en binaire.

PORTC = PORTC & B01111111;  // devrait mieux marcher

Les mots en binaire c'est pénible à manipuler.

PORTC = PORTC & ~(1 << PORT7) ; // pour mettre à 0
ou
PORTC = PORTC & ~(1 << PC7) ;   (suivant tes includes)

c'est plus facile et on fait moins d'erreur

PORTC = PORTC | (1 << PORT7) ; // pour mettre à 1

Exact CleoN

Il existe aussi des macro qui permettent de clarifier :

Code:

//Ecriture à 0 de PC7
bitClear(PORTC, 7);
for(int k = NbCantons*4 - 1; k >=  0; k--){
   //Ecriture à 0 de PC5
   bitClear(PORTC, 5);
   if(registersK[k]==HIGH){
      //Ecriture à 1 de PA6
      bitSet(PORTA, 6);
    }else{
      //Ecriture à 0 de PA6
      bitClear(PORTA, 6);
    }
   //Ecriture à 1 de PC5
   bitSet(PORTC, 5);
}
//Ecriture à 1 de PC7
bitSet(PORTC, 7);

Les commentaires en deviennent inutiles du coup

Bien vu, ces macros !

Quelle erreur de débutant !!! Merci à tous les deux !!

Petit point avancement :

1- Le code fonctionne parfaitement avec écriture directe (quand il n'y a pas d'erreur !! ). Apparemment, c'est bien plus rapide effectivement

2- J'ai reçu ce matin, mon 74HC259, donc, mis en place, modification du câblage et du code (avec écriture directe des sorties), ça fonctionne nickel !!
Voici le bout de code de ma fonction PWM (bien plus simple qu'avec le 74HC595) :

Code:

/*-------------------------------------------------------------------------------------------
 *                FONCTION PWM
 *-----------------------------------------------------------------------------------------*/
void pwm(){

  // Incrémentation du compteur
  compt_pwm++;

  // Si compteur=78
  if(compt_pwm==NbImpulsions){

    // Remise à zéro du compteur
    compt_pwm=0;

    // Reset de l'entrée MR du 74HC259 (pin 15)
    bitClear(PORTC, 3);
    bitSet(PORTC, 3);
  }

  // Boucle pour les cantons
  for(int iab=0;iab<NbCantons;iab++){

    // Si (compteur + consigne du canton) = 78
    // alors mise à 1 de la sortie correspondante
    if(compt_pwm+valeurPWM2[iab]==NbImpulsions){
      
      //Ecriture de l'adresse (0 à 8 = 3 bits)(pins 1/2/3)
      // Bit 0
      if(bitRead(iab, 0)==1){
        bitSet(PORTC, 4);
      }else{
        bitClear(PORTC, 4);
      }
      // Bit 1
      if(bitRead(iab, 1)==1){
        bitSet(PORTC, 2);
      }else{
        bitClear(PORTC, 2);
      }
      // Bit 2
      if(bitRead(iab, 2)==1){
        bitSet(PORTC, 0);
      }else{
        bitClear(PORTC, 0);
      }
      // Validation sur entrée LE du 74HC259 (pin 14)
      bitClear(PORTC, 1);
      bitSet(PORTC, 1);
    }
  }

}

3- Nouvelle vidéo pour vous montrer le 2ème écran avec suivi de la position des trains sur la tablette !!  

Résultat au top !!!

Bonjour,

J'ai commencé à lire tout le fil. Plein de choses intéressantes

Concernant le fait que les loco n'ont pas la même vitesse selon la fréquence de la PWM bien que le rapport cyclique soit le même, ça vient sans doute du transistor qui ne suit pas à haute fréquence. Pour bien faire, il faudrait un MOSFET qui permet de monter à plusieurs dizaines de kHz.

Tu as peut être également des condensateurs dans tes locos. Lorsque la PWM est on, le condensateur se charge en tirant le max de courant possible. Quand la PWM est off, la loco continue sur le condensateur. Ça explique pourquoi la loco démarre à fond passé un certain seuil.

Merci JLB.
De toute façon, si je n'arrive pas à remettre mes TLC5940, je devrais rester sur la création de ma propre PWM, et donc rester dans les 100Hz, où tout fonctionne correctement...
Et vu que le résultat est plus que correct avec les 74HC259, pourquoi revenir au TLC5940 ?
Mais, j'aimerais quand même arriver à les faire fonctionner ces sacrés 5940 !! Juste pour ne pas rester sur un échec...