Discussion :

[tuning1001]

Message déplacé depuis « Assembleur → Autres architectures ».

Bonjour ,

j'ai un programme à réaliser . je viens tout juste de commencé . j'ai installée MIKRO C PRO for PIC . le programme consiste à allumée de LED en sortie avec 4 entrée ce qui fait 2^4 = 16 possibilité moi je voudrais juste quand les entrée sont tousse a 1 les LED ( LED1 LED2 ) s'allume avec la procédure suivante 0 0 , 0 1 , 1 0 , 1 1 pendant 3 seconde par exemple pour les 4 possibilité .

Ma question est comment je fais pour ordonnée quand il y 1 1 1 1 sur le PORT A par exemple j'aurais le défilement des 4 possibilité 00 , 01 , 10 , 11 sur le PORT B configurer en sortie ?

Merci a vous .

[Obsidian]

Tout d'abord, programmes-tu en langage C ou directement en assembleur ? Ensuite, est-ce que tu veux faire un cycle complet (les quatre possibilités) en trois secondes ou cherches-tu à faire une pause de trois secondes entre deux changements d'état ?

Si c'est la seule tâche que tu aies à faire et que tu n'as pas envie de t'ennuyer à programmer les timers et autres, alors tu n'as pas le choix, il faut faire une boucle qui serve à la fois d'attente active et de test du port d'entrée. Donc :

1. Tu initialises une variable « led » à zéro ;
2. Tu envoies le contenu de cette variable vers le port B ;
3. Tu initialises une autre variable « compteur » à une valeur suffisamment haute, par exemple 30000 ;
4. Tu lis le port A ;
5. Tu lui applique un ET logique avec « 0x0F » (15 en décimal) pour ne conserver que les bits de poids faible ;
6. Tu vérifies sur le résultat vaut toujours » 0x0F » ;
7. Si ce n'est pas le cas, tu sautes vers la sortie (ou le début du programme) ;
8. Sinon, tu décrémentes « compteur » ;
9. Si compteur n'est pas n'est pas devenu nul, tu sautes à l'étape numéro 4 ;
10. Autrement, tu ajoutes « 2 » la variables « led » (ou tu l'incrémentes deux fois). C'est nécessaire parce que tes LEDs sont sur RB1 et RB2, et pas sur RB0 et RB1 ;
11. Tu appliques un ET logique avec « 0x06 » pour ne conserver que les deux bits qui nous intéressent ;
12. Tu sautes à l'étape 2.

Note importante : j'ai fait des raccourcis car il n'y a rien d'autre de branché sur tes ports A et B. Fais varier la valeur « 30000 » de l'étape 3 jusqu'à obtenir un cycle de la durée souhaitée.

[tuning1001]

Merci déjà de m'avoir répondu . effectivement je vais faire une pause de trois secondes entre deux changements d'état des deux Led's à la fois .
00 pose de 3s
01 pose de 3s
10 pose de 3s
11 pose de 3s

je programme en C sous MikroC PRO for PIC pas en assembleur qui va me prendre beaucoup de tache .

le programme au juste que je dois faire c'est le suivant :

j'ai 16 possibilité car 4 entrée 2^4= 16 et pour chaque code ( exemple 0100 ) J'ai les deux leds qui s'allume comme suit ( LED1 ( mise à 0 ) LED 2 (mise à 1 ) )

voila une photo pour comprendre mieux ce que j'aimerai faire ( le fonctionnement )

[ClaudeBg]

Salut
-------

Comme l'a dit Obsidian, la temporisation peut se faire à l'aide d'une simple boucle d'attente. MAIS ça nécessite de connaître le temps d'exécution de la boucle (pas évident en C) et évidemment de savoir comment calculer les temps de cycles, donc lecture du datasheet impérative dans ce cas, ce que, manifestement, tu cherches à éviter (mauvaise idée). Sauf à tatonner pour trouver le juste temps, mais bon, on ne programme pas une application comme ça, c'est du "bricolage".

Je pense qu'en C (pas adapté à un 16Fxxx, mais bon, vu ce que tu as à faire ça ne posera pas problème) tu dois avoir des méthodes de temporisation toutes faites qu'il te suffit d'appeler (ça varie d'un compilateur à l'autre, suffit de lire la doc des librairies du compilateur).

Pour le reste du code il te faut dessiner un ordinogramme (ou écrire un pseudo-code) et ensuite seulement commencer à coder. Ainsi, ce sera beaucoup plus clair pour toi, surtout si tu n'as aucune idée actuellement de la façon de procéder. Tu dois avoir une idée claire sur la méthode que tu vas utiliser, le code coulera de source (si tu as étudié les bases).

Contrairement à une idée reçue, l'utilisation du C sur PIC ne dispense pas d'un minimum d'apprentissage ni d'une bonne méthodologie de travail, parce que les questions que tu poses ne sont pas spécifiques aux PIC, ce sont des interrogations sur la structure même d'un programme ainsi que sur l'absence de lecture du manuel du compilateur.

Sinon, pour ton programme, c'est du niveau élémentaire:
- Une temporisation
- Une lecture de port
- Un switch en fonction des interrupteurs donnant 2 valeurs
- Une sortie sur base des deux valeurs.

Il te suffit d'appeler ta mini-routine d'allumage toutes les 3 secondes max ou min à chaque changement d'état des entrées, routine qui alterne entre deux valeurs enregistrées sur base de l'état de tes interrupteurs, sachant que les cas où on ne commute pas les sorties toutes les 3 secondes ne sont rien d'autre qu'un cas particulier d'alternance de deux valeurs dans lequel les deux valeurs sont identiques. C'est tout simple. Il y a juste une petite "difficulté concernant la tempo et la lecture du port d'entrée, qui fait qu'il est préférable d'utiliser un timer, mais je te laisse découvrir ça par toi-même, d'autant qu'Obsidian l'a soulevée dans son explication.

Dit autrement, tu peux réécrire ta table pour que toutes les lignes soient du type:
- Alternance entre la valeur 1 et la valeur 2 toutes les 3 secondes

Les lignes "sans alternance" n'étant que des cas où valeur 1 = valeur 2.
Du coup, il suffit de définir ces deux valeurs en fonction de la valeur des entrées, c'est un "bête" switch.




A+
Claude

[Obsidian]

Comme l'a dit Obsidian, la temporisation peut se faire à l'aide d'une simple boucle d'attente. MAIS ça nécessite de connaître le temps d'exécution de la boucle (pas évident en C) et évidemment de savoir comment calculer les temps de cycles, donc lecture du datasheet impérative dans ce cas, ce que, manifestement, tu cherches à éviter (mauvaise idée). Sauf à tatonner pour trouver le juste temps, mais bon, on ne programme pas une application comme ça, c'est du "bricolage".

C'est-à-dire qu'initialement, ce message a été déposé dans le forum Assembleur. En outre, les PIC sont des RISC qui se conforment à 1 cycle par instruction (sauf pour les sauts) et ces bébêtes fonctionnent généralement à 1 MHz (comme les 6809 de jadis). Il est donc assez facile de calculer une temporisation exacte.

Avec ça, il s'agit simplement de faire un effet lumineux, et ce dans le cadre d'un exercice. La temporisation n'a donc pas besoin d'être précise au cycle près non plus.

[ClaudeBg]

Salut
------

C'est-à-dire qu'initialement, ce message a été déposé dans le forum Assembleur.

Je ne te critiquais pas, je disais juste que vu l'utilisation du C, ce n'était pas évident du tout de calculer une boucle de temporisation. Or il indique explicitement travailler en C. J'indiquais en outre que c'est une mauvaise idée que ce ne pas vouloir étudier le datasheet, parce que, de toute évidence, il ne l'a pas étudié.

Je comprends ton erreur si tu as pensé qu'il programmait en langage d'assemblage vu le mauvais forum utilisé.

En outre, les PIC sont des RISC qui se conforment à 1 cycle par instruction (sauf pour les sauts) et ces bébêtes fonctionnent généralement à 1 MHz (comme les 6809 de jadis).

Pas vraiment.

Les PIC exécutent une instruction par temps de cycle et non pas temps d'oscillateur, avec un rapport de 4 : Tcy = 4 * Tosc.
Donc, déjà il faut 4Mhz d'oscillateur pour avoir 1µs.

Ensuite, je ne sais pas d'où tu sors ce 1Mhz. Un "bête" 16F84A, modèle le plus petit de la gamme Mid-range tourne sans problème à 20Mhz (osc). De simples PIC 8 bits 18F tournent à 48Mhz, voire 64MHz, et évidemment je passe sur les PIC 16 bits ou 32 bits, car, vu l'utilisation de Micro-C, je penche pour un 16F.

Ceci étant que, si son application n'a rien d'autre à faire, j'opterais si j'étais lui pour un oscillateur réglé beaucoup plus bas que 1Mhz, ça simplifiera ses tempos. Le PIC est un composant statique, on peut le ralentir autant qu'on veut (même jusque l'arrêt).

Il est donc assez facile de calculer une temporisation exacte.

Pas en C : On en revient au premier point : toi tu parles du contexte "assembleur" vu le mauvais forum utilisé, moi je parle C vu le contexte de son post.

Sans mettre le nez dans le programme compilé (ce qu'il ne peut pas faire, puisque pas de connaissance du langage d'assemblage) il lui est impossible de savoir le code généré par le compilateur et donc il ne peut ni maîtriser ni calculer le temps de sa boucle, sauf à opérer par "retouches au hasard". Surtout avec en plus une lecture de port et un switch dans la boucle.

Avec ça, il s'agit simplement de faire un effet lumineux, et ce dans le cadre d'un exercice. La temporisation n'a donc pas besoin d'être précise au cycle près non plus.

Il ne peut pas calculer le temps même avec un facteur d'erreur de 300%.
La preuve, demande-le-lui.
Un simple accès à une variable peut voir doubler ou quadrupler son temps d'accès rien que parce qu'un bon nombre de compilateurs ajoutent (pour les 16F) des changements de banque inopinés" (une instruction pour un 16F84, 2 pour un 16F876 par exemple)au cas où". En outre, il ignore totalement comment fonctionne le PIC et donc ne peut pas savoir quelles instructions sont nécessaires en langage d'assemblage pour faire une boucle, ou écrire dans un port, etc. Il ne peut donc avoir aucune idée, même vague, du temps pris par sa boucle.

Sans compter que vu l'énoncé, ce peut fort bien être un devoir d'école, auquel cas il a intérêt à garder une certaine précision quand même, et à expliquer à son prof comment il a bien pu calculer son temps de boucle.

Mon conseil est plutôt d'utiliser les librairies fournies avec son compilateur pour les tempos si elles proposent une gestion par timer, ou alors d'utiliser un timer directement.

L'idéal étant quand même d'utiliser les interruptions, mais bon, vu qu'il semble rechercher le minimum d'investissement, je doute que cette solution lui convienne, c'est pourquoi je n'en ai pas parlé.

A+
Claude