aide en programmation testeur de court-circuit et pinnage

j'ai déclaré" val" en int dont je pars juste a chaque fois changer la valeur mais comme c'est mon teste de continuité; donc val =0

et a, b sont déclarer au début en byte se sont les valeurs respectives des régistres de mes PCF receveurs.

Cependant, avec ce programme je n'arrive pas à faire afficher " y" seul lorsque " a ou b" ne sont pas égale a zéro.

lorsque "a " est différent de zero, ou lorsque mes receveurs lisent une valeur différente de val ?
alors, ils doivent afficher la pin défectueuse.

Mon soucis, est qu'il le fait mais il se met a incrémenté Y pas la suite ;ce qui est normal vue mon code mais, j'aimerai savoir s'il peux juste m'afficher la valeur de la pin défectueuse et s’arrête .

J'ai pensé a créer une interruption pour ca .

Mais, je ne suis pas très professionnel en programmation .

Merci de m'aider!

bonjour, à tous !

quelqu'un peut -il m'aidé ?

je cherche un expandeur semblable au PCF8575C mais , avec une autre façon de l'adresser un peut comme le PCF8574N et le PCF8574AN .

Merci ! de m'aider

Tu recherche un expandeur semblable au PCF8575C, pour une question de support si cet cella moi j'utilise des PCA 9555n en support DIP .
Ce sons aussi des 16 In/Out Sur bus I2C.

BONJOUR à Tous ,

il y a quelque temps je me suis inscrite sur ce site pour avoir de l'aide sur mon projet de TFE .

et j'ai eu plusieurs proposition qui m'ont aider jusqu'ici . J'ai même eu a y laissé mon cahier des charges sur ce topic pour parler des différents teste que je devais réaliser .

Aujourd’hui encore je vous demande de l'aide :frowning: pour mon dernier teste qui est : le teste de risque de croisements entre les 3pins d'une même paire audio sur un multicables-audio .

par exemple : une paire est constituer de ABC le teste consiste a dire si A est reliée à B ou C est reliée à B .

j'utilise des pcf8574 OU PCF8575 et j'ai pensé que je pourrai envoyer le code binaire 101 et si j'ai 011 ou 100 alors A ou C touche B .

je ne sais pas si c'est correct comme idée ou initiative .

Merci à tous de vouloir m'aide .

Cahier des charges.doc (297 KB)

bonjour,

j'ai des doute :~ sur ce programme j'aimerai savoir s' il est fiable ou non?

dans ce programme j'écris dans certains PCF et je lis dans d'autres que j'ai appelé" receveurs" .

Merci de me dire , si du moins j'ai bien programmer

#include "Wire.h"
#include <LiquidCrystal.h>

#define win1 0x20 // expandeur envoyeur

#define win2 0x22 //expandeur envoyeur

#define win3 0x21 //expandeur  envoyeur

#define win4 0x23 //expandeur  envoyeur

#define win5 0x24 //expandeur receveur

#define win6 0x25 // expandeur  receveur

#define win7 0x26 //expandeur  receveur

#define win8 0x27 //expandeur receveur

int dd=200; 
int val= 0;
byte a,b,c;
byte count;
int state = LOW;



// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);


 void setup() {

Wire.begin();

Serial.begin(9600);
lcd.begin(16, 2);
lcd.print(" test continuite");
//allOff(); // les valeurs par défaut PCF8574N à élevé, de sorte cette fonction désactive toutes les sorties hors


}

void testcontinu2()

{  

for (int y=1; y<9; y ++)

{
   Serial.println ();
// mettre toutes les broches de win1 a l'état haut 
Wire.beginTransmission(win1);
Wire.send(val);
Wire.endTransmission();

// Lecture des valeurs 
Wire.requestFrom(win3, 1);
a = Wire.receive(); 
Serial.println(); 
Serial.print ("RECEVOIR-"); 
Serial.print(a,DEC);
delay(dd+500);


if (a!=0 || b!=0)
{   
   //lcd.begin(16, 2);
  lcd.print("pin");
  lcd.print(y);
  delay(200);
  lcd.print("coupure ");
  Serial.print (" pin");
  Serial.print(y);
   delay(200);
  Serial.print("coupure ");
}
y=1;
}
for (int y=9; y<16; y ++)
{
  
// mettre toutes les broches de win2 a l'état haut 
Wire.beginTransmission(win2);
Wire.send(val);
Wire.endTransmission();
delay(dd+500);

// Lecture des valeurs 
Wire.requestFrom(win4, 1);
b = Wire.receive(); 
Serial.print ("RECEVOIR 2-"); 
Serial.print(b,BIN);
delay(dd+50);
//afficher la pin d'éffectueuse 
if (a!=0 || b!=0)
{ 

 Serial.print (" pin");
  Serial.print(y);
   delay(200);
  Serial.print("coupure ");
}  
}

for (int y=16; y<25; y ++)
{
  
   
// mettre toutes les broches de win2 a l'état haut 
Wire.beginTransmission(win5);
Wire.send(val);
Wire.endTransmission();
delay(dd+500);

// Lecture des valeurs 
Wire.requestFrom(win4, 1);
c = Wire.receive(); 
Serial.print ("RECEVOIR 3-"); 
Serial.print(  c,BIN);
delay(dd+50);
//afficher la pin d'éffectueuse 
if (a!=0 || b!=0|| c!=0)
{ 

 Serial.print (" pin");
  Serial.print(y);
   delay(200);
  Serial.print("coupure ");
}*/

}

 void loop()


{

  testcontinu2();
  
}

Ca commence mal

int val= 0;

// mettre toutes les broches de win1 a l'état haut 
Wire.beginTransmission(win1);
Wire.send(val);
Wire.endTransmission();

La première fois que tu passe ici, val vaut 0, donc tu met les broches .... à 0 :wink:

Et puis indente ton code comme il faut qu'on puisse le lire.
Ce qui permettra aussi de corriger les erreurs puisqu'il ne se compile pas.

b : même fautes : tu teste la valeur avant de l'avoir lue.

Donc non ce code n'est pas fiable.

Eh!! Mathy faut lire les réponses que l'on te fait. Je t'avais déjà mis sur cette piste il y a 2 semaines.

Bonjour , fdufnews

Merci! désolé avant je recevais vos réponse à mes question directement dans ma boite émail.

Mais maintenant je ne reçois plus rien .Mais ,je m'occuperais de ce problème.

En effet, je ne comprends pas trop ce que vous m’expliquiez ici :

Pourquoi! veux tu que j'initialise "b" dans la partie donc tu parle?

Merci!

Tu demandes si ton code est fiable.
Quand on constate que tu fait des tests if() sur des variables dans laquelle tu n'as encore mis aucune valeur, que veux tu qu'on te réponde ?
Non ton code n'est pas fiable car son comportement est non prédictif. Il dépend du hasard.

Je te rappele que le programme s'exécute dans l'ordre.

Déclaration de variable globale avec initialisation à 0 :

int val= 0;

Ensuite tu passe par loop() -> testcontinu2() et tu attaque par :

void testcontinu2()

{  

for (int y=1; y<9; y ++)

{
   Serial.println ();
// mettre toutes les broches de win1 a l'état haut 
Wire.beginTransmission(win1);
Wire.send(val);
Wire.endTransmission();

val vaut 0 donc toutes les pins passent à 0 !

D'ailleurs à aucun moment dans ton code tu met autre chose que la valeur 0 du départ dans val....
Donc tu persites à chaque Wire.send(val); à écrire 0 et encore 0 et toujours 0

bonjour, oui! c'est ce que je veux faire je met la valeur " 0"

ce qui met tous les pins de mon PCF d'entré a l'état haut

Ben non. RTFD.

vous ne m'avez pas compris ou peut être je m'explique mal .

ce programme fonctionne quand j'envois une valeur " val " il reçoit bien "val" et j'ai essayé de faire une simulation de mon programme sur breadbord !
donc! j'ai placé une LED sur chaque broche I/O de mon pcf d'entrés et toutes les leds s'allume lorsque val faut "0"

mais maintenant que je veux lire la valeur " val" au travers des broches de mes pcf de sorties c'est la que j'ai un problème.

pour quoi! non?

et que veux dire RTFD

RTFD : Read That F....g Datasheet, c'est dans ma signature.

Pour avoir un niveau HAUT en sortie tu dois écrire un 1.
Pou rutiliser un pin en entrée il faut d'abord écrire un 1.
Tu passes ton temps a n'écrire que des 0, donc tes broches sont en permanence en sortie au niveau bas en ne peuvent pas être utilisée pour des entrées.

Voir Figure 9 page 9 et paragraphe 7.3 page 12.

ce programme fonctionne quand j'envois une valeur " val " il reçoit bien "val" et j'ai essayé de faire une simulation de mon programme sur breadbord !
donc! j'ai placé une LED sur chaque broche I/O de mon pcf d'entrés et toutes les leds s'allume lorsque val faut "0"

Ce qui veut dire que tu as branché comme cela :
VCC ---|>|---xxxx---- PCF

Donc ta led s'allume quand la broche du PCF est à 0.

oui!

bonjour, j'ai une question?

est ce que quelqu'un peut me dire si possible pourquoi est ce que ! mon bus I2C fait bugger mon programme?

en effet, je suis entrain de réaliser mon projet , j'ai tiré mes carte ou mes circuit et j'ai une carte pour mes PCF d'entrés , un carte pour mes PCF de sortit et une carte principal sur la quel j'ai placé mon microcontroleur .

Cependant, lorsque je branche mes carte sans connecté le bus I2C , le programme tourne et dès que je connecte celui -ci sur le autres cartes, le programme s’arrête de tourné .

Je n' y comprend rien quelqu'un a -t-il déjà eu se problème? :frowning:

Et où s’arrête t'il de tourner ?
Cela pourrait aider ...

Bonjour , j'ai modifié je programme et c'est le suivant .

j'ai mit dans mon void loop un led qui clignote pour que je puisse savoir si oui ou non le programme tourne bien .

Je met rend compte que oui! maintenant il tourne a mon avis c'était un problème d'adresses .

car , j'ai recommencé le programme a zéro . particulièrement les adresses et aussi sur ma carte qui est une double face et c'est la première fois que j'en tire une j'ai fait certaine erreurs .

Mais cependant , j'aimerai avec celui ci stoké les valeurs lus par mes PCFde sortis dans un tableau " PCF_SORTIT*" et les i représente un bit dans un OCTET .*
```
#include "Wire.h"
#include <LiquidCrystal.h>

// Adressage des expandeurs
#define Entrechip1  0x20 //  binaire 0x20
#define Entrechip2  0x21 //  binaire 0x21
#define Entrechip3 0x22//  binaire 0x22
#define Entrechip4 0x23// binaire 0x23
#define Entrechip5 0x24//  binaire 0x24
#define Entrechip6 0x25 //  binaire 0x25
#define Sortichip1  0x26//  binaire 0x26
#define Sortichip2  0x27//  binaire 0x27
#define Sortichip3  0x38//  binaire 38h
#define Sortichip4  0x39//  binaire 39h
#define Sortichip5  0x3A//  binaire 3Ah
#define Sortichip6  0x3B//  binaire 3Bh
#define Sortichip7  0x3C//  binaire 3Ch
#define Sortichip8  0x3D//  binaire 3Dh
#define Sortichip9  0x3F//  binaire 3Eh
#define LENGTH_REGISTER 8

int dd=200;
int val= B11111111;
int a,b,c;
byte x,y,u,v,w,s,z,p,t,m,n;
byte count;
int tableau[100];
byte PCF_SORTIT[LENGTH_REGISTER]; //Tableau contenant les valeurs des PCF au format binaire
int NUM_BROCHE [LENGTH_REGISTER];  //Tableau contenant les valeurs des PCF convertit en entier.

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {

Wire.begin();

Serial.begin(9600);
lcd.begin(16, 2);
lcd.print(" test continuite");
allOff(); //  toutes les sorties à l'état haut

pinMode(13, OUTPUT);
}

void testcontinu2( int cable)

{

if ( cable == 25)
  {
   
for (int a=1; a<16; a ++)

{
 
// mettre toutes les broches de win1 a l'état haut
Wire.beginTransmission(Entrechip1);
Wire.send(val);
Wire.send(val);
Wire.endTransmission();
// Lecture des valeurs

Wire.requestFrom(Sortichip1, 2);
x = Wire.receive();
y = Wire.receive();

}
for (a =17; a<26; a++)
{
Wire.beginTransmission( Entrechip2);
Wire.send(val);
Wire.send(val);
Wire.endTransmission();
Wire.requestFrom(Sortichip2, 2);
t = Wire.receive();
u = Wire.receive();
}
  }
  // fin de test DB25
 
  if( cable==37)
  {
  for ( a=1; a<17;a++)
  {
Wire.beginTransmission(Entrechip1 );
Wire.send(val);
Wire.send(val);
Wire.endTransmission();
Wire.requestFrom(Sortichip1, 2);
x = Wire.receive();
y = Wire.receive();
  }
  for( a=17; a<33 ;a++)
  {
Wire.beginTransmission(Entrechip2);
Wire.send(val);
Wire.send(val);
Wire.endTransmission();
Wire.requestFrom(Sortichip2, 2);
t = Wire.receive();
u = Wire.receive();
  }
  for ( a= 33 ; a<38; a++)
  {
Wire.beginTransmission( Entrechip3);
Wire.send(val);
Wire.send(val);
Wire.endTransmission();
Wire.requestFrom(Sortichip3, 1);
v = Wire.receive();
Wire.requestFrom(Sortichip4, 1);
w = Wire.receive();
  }
  } // fin de test de SOcapex
 
  if (cable==85)
  {
    for ( a=1; a<17; a++)
    {
Wire.beginTransmission(Entrechip1);
Wire.send(val);
Wire.send(val);
Wire.endTransmission();
Wire.requestFrom(Sortichip1, 2);
x = Wire.receive();
y = Wire.receive();
    }
    for( a=17; a< 33; a++)
    {
Wire.beginTransmission(Entrechip2);
Wire.send(val);
Wire.send(val);
Wire.endTransmission();
Wire.requestFrom(Sortichip2, 2);
t = Wire.receive();
u = Wire.receive();
    }
    for( a=33 ; a<49; a++)
    {
Wire.beginTransmission(Entrechip3);
Wire.send(val);
Wire.send(val);
Wire.endTransmission();
Wire.requestFrom(Sortichip3, 1);
v = Wire.receive();
Wire.requestFrom(Sortichip4, 1);
w = Wire.receive();
    }
    for( a=49; a<66; a++)
    {
Wire.beginTransmission( Entrechip4);
Wire.send(val);
Wire.send(val);
Wire.endTransmission();
Wire.requestFrom(Sortichip5, 1);
s = Wire.receive();
Wire.requestFrom(Sortichip6, 1);
z = Wire.receive();
    }
    for( a=66; a<82 ; a++)
    {
Wire.beginTransmission( Entrechip5);
Wire.send(val);
Wire.send(val);
Wire.endTransmission();
Wire.requestFrom(Sortichip7, 1);
m = Wire.receive();
Wire.requestFrom(Sortichip8, 1);
n = Wire.receive();
    }
    for( a=82; a<86 ;a++)
    {
Wire.beginTransmission(Entrechip6);
Wire.send(val);
Wire.send(val);
Wire.endTransmission();
Wire.requestFrom(Sortichip9, 1);
p = Wire.receive();

}
  }
}
// FONCTION DE CONVERSION DE VALEUR DECIMAL EN BINAIRE
/*void decToBin(int dec){ //effectue la conversion decimal vers binaire
  int i=0;
  for(i=0;i<8;i++){
    if(dec%2==1){
      lightLed(i,true);
    }else{
      lightLed(i,false);
    }
    dec=dec/2;
  }
}
void loop() {
  int i=0;
  for(i=0;i<256;i++){ //boucle principale
    decToBin(i);
    delay(200);
  }
}
// Effacer des caractères d’un point A à un point B sur une même ligne
void clear(byte ligne, byte debut, byte fin) {

for(byte i = debut ; i <= fin ; i++){

lcd.setCursor(i, ligne);

lcd.print(' ');
}

}
*/
void stockage1() // fonction pour stoker les valeurs des PC8575 de sortis ds 1 tableau
{
  for(int i = 0; i < LENGTH_REGISTER; i++)
    {
        PCF_SORTIT[i] = Wire.receive(); //Enregistrement des 1 octects dans PCF_SORTIT
    }
    for(int i =10; i < LENGTH_REGISTER; i++)
    {
        PCF_SORTIT[i] = Wire.receive(); //Enregistrement des 1 octects dans PCF_SORTIT
      }
      //Serial.print(  PCF_SORTIT[i], BIN);
     
    //return 0; 
}

void stockage2() // fonction pour stoker les valeurs des PC8574A de sortis ds 1 tableau
{
  for(int i = 0; i < LENGTH_REGISTER; i++)
    {
        PCF_SORTIT[i] = Wire.receive(); //Enregistrement des 1 octects dans PCF_SORTIT
    }
   
    //return(); 
}
void allOff()

{

Wire.beginTransmission(Entrechip1);
Wire.send(B00000000);
Wire.send(B00000000);
Wire.endTransmission();
Wire.beginTransmission(Entrechip2);
Wire.send(B00000000);
Wire.send(B00000000);
Wire.endTransmission();
Wire.beginTransmission(Entrechip3);
Wire.send(B00000000);
Wire.send(B00000000);
Wire.endTransmission();
Wire.beginTransmission(Entrechip4);
Wire.send(B00000000);
Wire.send(B00000000);
Wire.endTransmission();
Wire.beginTransmission(Entrechip5);
Wire.send(B00000000);
Wire.send(B00000000);
Wire.endTransmission();
Wire.beginTransmission(Entrechip6);
Wire.send(B00000000);
Wire.send(B00000000);
Wire.endTransmission();
}

void loop() {
 
  digitalWrite(13, HIGH);  // set the LED on
  delay(3000);              // wait for a second
  digitalWrite(13, LOW);    // set the LED off
  delay(3000);              // wait for a second

}*
```
je vous envois le programme si vous pouviez m'aider . merci!

// Adressage des expandeurs
#define Entrechip1 0x20 // binaire 0x20
...
#define Entrechip6 0x25 // binaire 0x25
#define Sortichip1 0x26// binaire 0x26
...
#define Sortichip9 0x3F// binaire 3Eh

Pourquoi ne pas faire un tableau ?

byte AdrChipEntree[6] = { 0x20, ..... ajoute la suite };
byte AdrChipSortie[10] = { 0x26, ..... };

byte PCF_SORTIT[LENGTH_REGISTER]; //Tableau contenant les valeurs des PCF au format binaire
int NUM_BROCHE [LENGTH_REGISTER]; //Tableau contenant les valeurs des PCF convertit en entier.

Pourquoi avoir besoin de convertir en int ?
Et dans ce cas, pourquoi passer par un tableau intermédaire
Tu as parfaitement le droit de faire :

int x = Wire.receive()

Le compilateur C va automatiquement élever le type retourné par Wire.receive() de byte à int.
Tant que tu va d'un type plus petit vers un type plus grand, il n'y a aucun problème.
Dans l'autre cas, tu peut avoir besoin de faire un "cast" (transtypage en français) pour forcer une conversion d'un type plusgrand vers un type plus petit.

// mettre toutes les broches de win1 a l'état haut
Wire.beginTransmission(Entrechip1);
Wire.send(val);
Wire.send(val);
Wire.endTransmission();

Il me semble qu'il y a un seul registre dans le PCF. Donc un seul Wire.send() suffisant.

Wire.requestFrom(Sortichip1, 2);
x = Wire.receive();
y = Wire.receive();

Même chose ici, pourquoi 2 lectures ?

PCF_SORTIT = Wire.receive(); //Enregistrement des 1 octects dans PCF_SORTIT[/quote]
Apparemment tu sais comment obtenir le résultat dans un tableau donc je ne comprend pas ta question.
Ton programme me semble excessivement compliqué.
Tu manques de généricité dans ton code : tu dupliques du code identique qui devrait pouvoir dépendre de variables.
Par exemple, si tu dois allumer/éteindre un fil de sortie 1 par 1 pour tester les entrées, tu peux faire une fonction dans la même idée que digitalWrite :
```
*byte MemoireSortie[10] = { 0, }; // mémoriser l'état des Write sur les PCF car on ne peut pas relire

void pcfWrite(
  byte bit, /* numero du bit de 0 à 79 /
  byte value /
0 ou 1 */
)
{
    byte chip = bit >> 3; // on divise par 8 pour savoir sur quel chip de sortie
    bit = bit & 3; // on ne garde que les 3 bites de poids fort : 0..7

Wire.beginTransmission( AdrChipSortie[chip] );
    if ( val == 0 )
        MemoireSortie[chip] &= ~_BV(bit);
    else
        MemoireSortie[chip] |= _BV(bit);
    Wire.send( MemoireSortie[chip] );
    Wire.endTransmission();
}*

```
A+

Bonsoir ! barbudor

tout d'abords je tenais a vous remerciez pour votre aide je comprends maintenant mieux .

cependant avec ça :

Wire.send(255); 
                               Wire.send(255)

je veux écrire dans 2octet car j'utilise des PCF8575 16BITS