Discussion :

[max.cort]

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!

[Obsidian]

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.

[max.cort]

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

[Obsidian]

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.

[max.cort]

Bonjour,

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

[deletme]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[max.cort]

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

[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 |

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Si ici je fais un simple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Si maintenant on reprend

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Dans l'ordre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

PORTB & 0x01

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ^^

[max.cort]

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

[deletme]

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 |
-----------------

[minnesota]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Neckara]

Bonjour,

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.

[Obsidian]

Hello,

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.

[deletme]

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).

[Obsidian]

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.