Programmer un pic

Alors je début je vais essayer d'être le plus claire possible sur le programme voulu.
9 entrées qui sont pilotées par des inters qui formes de séquences.
7 sorties qui piloterons des leds pour indiquer la situation du système.
La led_1 = 1 si les entrées 1 , 2 , 3 , 4 ,5 ,6,7 sont a 1 et que 8 et 9 sont a 0
La led_2 = 1 si les entrées 1 , 2 , 3 , 4 ,7 sont a 1 et que 5 , 6, 8 et 9 sont a 0
La led_3 = 1 si les entrées 1 , 2 , 3 , 4 sont a 1 et que 5 , 6,7 , 8 et 9 sont a 0
La led_4 = 1 si les entrées 3 , 4, 8, 9 sont a 1 et que 1 ,2 ,5 , 6,7 sont a 0
La led_5 = 1 si toutes les entrée sont a 0
La led_6 = 1 si l entrée 7 sont a 1 et que 1, 2, 3 ,4,5 , 6, 8 et 9 sont a 0
La led_7 = 1 si les entrées 5 , 6,7 sont a 1 et que 1, 2, 3 ,4, 8 et 9 sont a 0

Un paramètre dont je n'est pas parlé est que les séquences des inters peuvent être aléatoire... donc le" if " ne focntionne pas, apart si vous connaissez un astuce.

merci pour votre aide!

Bonjour et bienvenue,

• Merci de respecter la netiquette en utilisant notamment les formules de politesse d'usage : « bonjour », « merci » (ça, c'est fait) et « au revoir » ;
• Cela va dépendre essentiellement du modèle du PIC que tu utilises ;
• Étant donné que chaque LED ne doit s'allumer que sur une configuration d'entrée fixe et indépendante de tes ports d'entrée, il te suffit de les lire en une seule fois et de les considérer comme un entier binaire :

— Allumage LED 1 si la valeur lue est 0x07F ;
— Allumage LED 2 si la valeur lue est 0x04F ;
— Allumage LED 3 si la valeur lue est 0x00F ;
etc.

Il te suffit de faire une boucle au début de laquelle tu lis l'entrée de tes ports dans un registre sur lequel tu vas ensuite faire des comparaisons successives avec ces valeurs. À l'issue de chaque comparaison, tu mets le bit correspond à la LED idoine à 0 ou à 1.

À la fin de ta boucle, tu reprends au début.

Tout d'abord bonjour.

Je viens de me noyer dans 200 pages de formation et je vois pas comment faire des comparaisons successives.
Merci
Bonne soirée

Citation:

---

Envoyé par max.cort

Je viens de me noyer dans 200 pages de formation et je vois pas comment faire des comparaisons successives.

---

Ce n'est pas un terme technique. J'essayais juste de te dire de comparer successivement l'état du port que tu as récupéré à chacune des valeurs précalculées ci-dessus.

Donne-nous le modèle de ton PIC.

Bonjour,

Merci pour ton aide, mon pic est un 18F4550.

Salut,

En reprenant ce qu'Obsidian te propose, voici ce à quoi ça ressemblerait pour une LED (je pars du principe que tes entrées sont sur RA0 à RA7 et que la 9eme sur le RB0) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// n'oublie pas la librairie de ton pic #define LED1 LATCbits.RC0 #define MASQUE_LED1 0x0FC // 1 , 2 , 3 , 4 ,5 ,6,7 sont a 1 et que 8 et 9 sont a 0 int main () {   // intialisationd des ports (a faire)   int temp = 0;   while(1) {   temp = PORTA | ( (PORTB & 0x01) << 8); // lecture des ports et isolation des entrée interrupteurs LED1 = ((temp & MASQUE_LED1) == MASQUE_LED1); }

---

Voilà l'idée, je n'ai pas testé si ça compilait mais tu devrais pouvoir t'en sortir.

Je me posait une question est quelque chose comme sa fonctionnerai:
Mes entrée a, b, c, d.....

LED_1 = a==1 && b==1 && c==1 && d==1 && e==0 && f==0 && g==0

ou

LED_1 = a && b && c && d && !e && !f && !g

?

Un petit quelque chose a mon niveau....
Merci

Oui tu peux te servir des équations booléennes comme tu le proposes mais attention à la syntaxe :

• Le ET logique s'écrit &

• Le OU logique s'écrit |

Code:

---

LED1 = PORTAbits.RA0 & PORTAbits.RA1 & !PORTAbits.RA2;

---

Le code que je t'ai proposé ne fait qu'une lecture en début de boucle des différentes entrées. La ligne

Code:

---

temp = PORTA | ( (PORTB & 0x01) << 8); // lecture des ports et isolation des entrée interrupteurs

---

permet en fait de positionner la valeur de tes entrées "côte à côte" dans une seule variable. Par exemple :

Code:

---

1 2	unsigned char valeur1 = 0xCC; unsigned char valeur2 = 0x3B;

---

Si ici je fais un simple

Code:

---

valeur1 | valeur2

---

, les deux variables vont se mélanger. Pour éviter ça, j'utilise l'opérateur << de décalage qui permet comme son nom l'indique de décaler les bits de la variable sur laquelle il s'applique dans le sens des flèches et du nombre de bit indiqué.

Code:

---

1 2 3

unsigned char test = 0x01; //00000001b test = test << 2; // ici test = 00000100

---

Si maintenant on reprend

Code:

---

temp = PORTA | ( (PORTB & 0x01) << 8)

---

Dans l'ordre :

Code:

---

PORTB & 0x01

---

permet de ne garder que la valeur qui nous intéresse, le bit de poids faible.

Code:

---

(PORTB & 0x01) << 8

---

permet de décaler ce bit de poids faible de 8 bits vers la gauche. Le résultat temporaire de ce calcul contient 100000000b soit 0x0100 (pas temp attention).

Code:

---

PORTA | ( (PORTB & 0x01) << 8)

---

fait l'opération du OU logique entre PORTA et le résultat obtenu juste au dessus. ça y est, la valeur des ports sont côte à côte dans une même variable (temp).

Ensuite

Code:

---

LED1 = ((temp & MASQUE_LED1) == MASQUE_LED1);

---

ici on fait l'opération ET bit à bit pour masquer les bits qui ne nous intéressent pas (qui correspondent aux interrupteurs) et on peut vérifier si nos différents interrupteurs sont allumés ou éteints.

Essayes de refaire ces différentes opérations sur papier et tu verras que ce n'est pas si compliqué que ça ^^

Deux choses on du mal a passer:
Les hexadicimal j'ai du mal a voir a quoi il correspondent, est ce qu'il correspondent a mes séquence d' interrupteurs?
et temp je sais pas ce que sa fait.

Merci de ton extreme patience

Oui, dis moi quelles lignes posent problème.

Si tu fais référence aux valeurs hexa de valeur1 et valeu2 ce ne sont que des exemples donc j'ai mis des valeurs au hasard.

Le temp (je te l'accorde le nom n'est pas bien choisi mais je manque d'inspiration) qui est un entier est codé sur 16 bits soit deux octets :
-----------------
|octet2 | octet1|
-----------------
Pour lire plus facilement les entrées, je les stocke comme ceci dans temp :
-----------------
|PORTB | PORTA |
-----------------

Salut,

pour ce genre de chose on a effectivement le choix entre plusieurs approches, mais je pense qu'une union avec une structure anonyme de champs de bits serait plus adaptée ici, ça aurait en tout cas le mérite d'être plus intuitif et élégant pour peu que le code suive. Bien sûr, il ne faut pas perdre de vue que l'alignement et le séquençage dépendent hautement de la plateforme.

Je programme essentiellement en C++, mes rudiments de C ne sont pas exempts de lacunes, mais en gros pour l'union ça donnerait quelque chose comme

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

typedef union { struct { unsigned pin1 : 1; unsigned pin2 : 1; unsigned pin3 : 1; unsigned pin4 : 1; unsigned pin5 : 1; unsigned pin6 : 1; unsigned pin7 : 1; unsigned pin8 : 1; unsigned pin9 : 1; }; uint16_t stat; //si uint16_t pas pris en charge, le remplacer par unsigned } pins;

---

avec un petit typedef pins led;, on pourrait initialiser le statut déclenchant de chaque led avec

Code:

---

1 2	const led led2= {.pin1=1, .pin2=1, .pin3=1, .pin4=1, .pin5=0, .pin6=0, .pin7=1, .pin8=0, .pin9=0}; const led led3= ...

---

Pareil, pour enregistrer l'état des pins :

Code:

---

1 2 3 4 5 6

pins p= {{0}}; p.pin1= 1; p.pin2= 1; p.pin3= 1; p.pin4= 0; ....

---

Ensuite une simple comparaison avisera s'il faut ou pas allumer telle ou telle led

if (led2.stat==p.stat) printf("led2 ON"); else printf("led2 Off");

voilà pour les grandes lignes.

Bonjour,

Citation:

---

Envoyé par deletme

Oui tu peux te servir des équations booléennes comme tu le proposes mais attention à la syntaxe :

• Le ET logique s'écrit &

• Le OU logique s'écrit |

---

Je ne suis pas d'accord,

Le ET logique est &&, c'est un opérateur logique si la première expression est fausse, la seconde ne sera pas évaluée. Il retourne true (1) si les deux expressions valent true ( != false ie != 0) sinon false (0).

& est un opérateur bit à bit (!= ET logique), les deux expressions sont évaluées.
Pour x = y & z, le bit xi sera égal à yi && zi.

Hello,

Citation:

---

Envoyé par Neckara

Le ET logique est &&, c'est un opérateur logique si la première expression est fausse, la seconde ne sera pas évaluée. Il retourne true (1) si les deux expressions valent true ( != false ie != 0) sinon false (0).

& est un opérateur bit à bit (!= ET logique), les deux expressions sont évaluées.
Pour x = y & z, le bit xi sera égal à yi && zi.

---

Pour être exact, ce sont bien des ET logiques dans les deux cas. Ces « ET » et « OU » sont les homologues des ∧ et ∨ de la logique du premier ordre. Ce n'est qu'ensuite que l'on fait la distinction. D'un côté les pseudo-ET et OU dont les opérandes sont des booléens, si bien que leur arguments sont d'abord convertis avant d'être évalués, et de l'autre les ET et OU logiques bit à bit.

Dans certains langages, les pseudo-ET et OU n'existent pas. Il n'y alors qu'un seul type d'opérateur logique et il faut alors faire attention, quand on utilise des « AND », à éviter les faux négatifs.

Salut,

Neckara tu as raison dans le sens où en prenant ta syntaxe l'évaluation de l'équation sera plus rapide qu'avec la mienne (comme tu dis, on s'arrête dès qu'une opération logique est fausse).

Citation:

---

Envoyé par deletme

Neckara tu as raison dans le sens où en prenant ta syntaxe l'évaluation de l'équation sera plus rapide qu'avec la mienne (comme tu dis, on s'arrête dès qu'une opération logique est fausse).

---

Ce n'est pas forcément vrai : ça l'est si les deux opérandes sont complexes et ont des effets de bord mais s'il s'agit de faire une opération logique sur deux entiers, faire cette opération ou comparer une opérande avec zéro revient au même.