Problème Résistances PULL UP sur sorties PIC18F45K22

[invite0e0d6f65]

Bonjour tout le monde,

Dans le cadre d'un projet je souhaite faire communiquer un capteur de CO2 avec un PIC18F45K22. La communication doit être effectuer via un bus 2 fils (CLK, DATA). Les 2 fils de ce bus doivent être à l'état haut au repos, ceci grâce à des résistances de tirages qui doivent être comprises entre 4,7k et 100k OHM. Mon problème est que lorsque je branche le bus à mon PIC18F45K22 sur les RB1 et RB2 , sa tension au repos chute quelque soit la valeur de la résistance de PULL UP alors que débrancher du PIC la tension est à sa valeur haute...

Voici grosso modo le schéma utilisé :



Et voici la configuration du PORTB de mon PIC :

  OSCCON = 0x62 ;
  PORTB = 0x00 ;
  TRISB = 0x00 ;

Quelqu'un serait-il m'expliquer pourquoi je n'obtiens pas le résultat voulu ?

Par avance merci de vos réponses .
-----

[invite3ad61e0c]

Salut denver,

Perso je ne m'y connais trop mais tu n'aurai pas un problème car tes sorties ne sont pas de type collecteur ouvert?

Tu cherches à faire de l'I2C là?

A+

[invite0e0d6f65]

Non c'est un dérivé de l'I²C conçu par la marque de mon capteur de CO2

[invite3ad61e0c]

Bon alors je pense que tu as un pb car tes sorties ne sont pas à collecteur ouvert c'est un peu comme de l'I2C :

http://fabrice.sincere.pagesperso-or...2C_16F876A.htm

Regarde chapitre 2...

Logique il te faut un collecteur ouvert pour pouvoir appliquer un niveau bas sur ton bus....

[A voir en vidéo sur Futura]

[invitedb9b1ced]

Salut,

Tu fais :

OSCCON = 0x62 ;
PORTB = 0x00 ;
TRISB = 0x00 ;

Donc :
PORTB = 0x00 ; -> toutes les valeurs du PORTB à 0.
TRISB = 0x00 ; -> tout le PORTB en sortie.

Donc tu as tout à 0 sur le port B.

CQFD.

[paulfjujo]

bonjour,

Quelle est la configuration des bits,
PBADEN=0
pour inhiber la config Port B Analog..

Quel est ton code complet
Config + init ..

attention RB1 est SCLK <--> Clk ?
et RB2 SDA <---> DATA ?
Mode I2C Master ou Slave coté PIC ?

des pull up de valeur 4,7K me parait une valeur normale ..
perso je n'ai jamais vu de valeur aussi elevée que 100K

[invite0e0d6f65]

@TONAVE72 : merci pour cette réponse qui je crois, est le bon chemin à suivre. Cela voudrait dire qu'il faut que je me branche sur des pins utilisées pour l'I²C. Mais comment configurer ces pins ?

@amoniaque : je n'ai pas bien compris ton raisonnement concernant la configuration de mon port B. Je veux que mon bus reste à l'état haut au repos lorsque je le branche sur mes PINS RB1 et RB2. Là quand je le branche il passe de l'état haut à l'état bas quasi-instantanément.

[invitedb9b1ced]

Etant donné que tu configures tes pins en sortie, que tu appliques la valeur "0" sur ces sorties, il est normal que tu aies donc un état bas sur tes sorties...
Si tu veux avoir un état haut (forcé) il suffit de mettre un "1" sur LATBx ou alors (de manière pull up cette fois) de mettre tes pins en entrée.

[invite0e0d6f65]

@paulfjujo : voici mon code complet

[CODE]
#include <p18f45k22.h>
#include <delays.h>
#include "e2_interface.h"

#pragma config WDTEN = OFF // Watch Dog Timer disabled
#pragma config FOSC = INTIO67 // Internal Oscillator Block, RA6 & RA7 enabled
#pragma config DEBUG = ON // Background Debug enabled
#pragma config LVP = OFF // Low Voltage Programming disabled
#pragma config MCLRE = INTMCLR // RE3 enabled, MCLR disabled

unsigned char dummy = 0 ;
unsigned char status = 0 ;
unsigned int acq_co2 = 0 ;

void main()
{
OSCCON = 0x62 ;
PORTB = 0X00 ;
TRISB = 0x00 ;

dummy = ee891_status() ; // Démarre une mesure

while(1)
{
acq_co2 = co2_read() ; // acquisition du taux de CO2 en PPM
status = ee891_status(); // Lecture du status du capteur
}

}
[\CODE]

Pour rappelle ce n'est pas de l'i2c, c'est un dérivé créé par la marque du capteur de CO2 ! (E2 interface). Mais sinon le PIC est le maitre puisque c'est lui qui génère le signal d'horloge. Pour les résistance de pull up, ce sont des valeurs trouvées dans le datasheet du capteur.

@amoniaque : je ne cherche pas à appliquer une valeur 0 ou 1 sur mes pins en sorties, je cherche à avoir un niveau au repos sur mon bus.

[paulfjujo]

Comme le precise Amoniaque, tu peux au debut de ton init mettre les pins B1 et B3 en entrees
mais ensuite c'est la subroutine Hardware I2C :
OpenI2C(MASTER,SLEW_OFF) (exemple en C18)
qui te configureras tes pins correctement ...
voir docu sur les librairies C18...

ou alors à toi d'utiliser des subroutines en SOFT I2C

[invitedb9b1ced]

Sinon :

http://www.robot-electronics.co.uk/a..._Tutorial.html.

Rien de tel pour te tenir la main et t'aider à comprendre de bout en bout .
Et tu remarqueras que pour avoir ton niveau haut via pull up, la pin est configurée en input.

A+

[invite3ad61e0c]

Denver,

Alors en effet tu peux surement utiliser les Pin I2C mais là, vu que tu ne fais pas de "vrai" I2C et ne connaissant pas ton protocole, je ne sais pas si tu peux t'en sortir.

Regarde au niveau des registres de configuration de l'I2C (de mémoire : SSPSTAT, SSPCON, SSPCON2,...) mais cela est pour le 16F876 je ne sais pas si dans ton cas ce sont les mêmes registres et es tu sûr que ton pic propose de l'I2C? (on ne sait jamais).

Sinon, ton pic peut commander un transistor qui appliquera un 0V sur ton bus lorsque la sortie est à 1 (si tu veux un schéma fais moi signe).

J'espère avoir été assez clair...

[invitedb9b1ced]

Sinon comme indiqué par paulfjujo, tu peux certainement utiliser les pins dédiées (RC3-4 et RD0-1) au module MSSP (en I²C) ? Cela éviterait d'utiliser RB1 et RB2 qui ne sont pas dédiées à ce module.

[paulfjujo]

puisque c'est le PIC qui est maitre
RB1 = output initialisee à 1 -> clock pour le device CO2 CLK
RB2= input (à 1 par defaut via le pull up) <- data from device CO2 DATA

ton schema de connection est contraire à cela...

Apres cela depend des subroutines contenues dans ton header "e2_interface.h"
et en particulier de l'init du protocole e2.

[invite0e0d6f65]

Est-il possible d'utiliser des pins dédiées à l'I2C si on utilise un protocole différent de l'I2C ?

[paulfjujo]

Cela éviterait d'utiliser RB1 et RB2 qui ne sont pas dédiées à ce module.

il est vrai que sur d'autres PIC c'est RC3 -RC4 qui sont utilises pour l'I2C
mais sur la datasheet en table 10-5 il apparait bien
RB1 MSSP2 I2C Clock output.
RB2 MSSP I2C Data input
mais perso, je ne l'ai jamais utilisé

[paulfjujo]

Est-il possible d'utiliser des pins dédiées à l'I2C si on utilise un protocole différent de l'I2C ?

Oui, c'est le mode I2C Software Bit Bang.
Il suffit de configurer les pins en E/S classiques
souvent utilise avec les PIC qui n'ont pas de Harware I2C incorporé.

On peut ainsi adpater le protocole..

[invite0e0d6f65]

Franchement là, vous m'avez complètement perdu. Désolé je suis un débutant...

[invite0e0d6f65]

Pourquoi la PIN DATA devrait être en entrée alors qu'il faut qu'elle génère des trames de commande ?

[paulfjujo]

si on repart de ton post #1
l'etat de tes sorties RB1 et RB2 dependent effectivement de l'init des pins
MAIS AUSSI de tes subroutines contenues dans ton header "e2_interface.h"
qui doivent en modifier le comportement.

Poste le code de e2_interface.h

Par anlogie à l'I2C il me semble que les liaison RB1-Data et RB2-clck sont inverses.. A suivre..

[invite0e0d6f65]

@paulfjujo : voici le code associé à e2_interface.h

#include "e2_interface.h"

// variables
unsigned char co2_low;
unsigned char co2_high;
unsigned char checksum;
unsigned int co2_ee891= 0;
unsigned int co2 = 0 ;

void E2Bus_start(void) // send Start condition to E2 Interface
{
set_SDA();
set_SCL();
delay(30*DELAY_FAKTOR);
clear_SDA();
delay(30*DELAY_FAKTOR);
}
/*-----------------------------------------------------------------------*/
void E2Bus_stop(void) // send Stop condition to E2 Interface
{
clear_SCL();
delay(20*DELAY_FAKTOR);
clear_SDA();
delay(20*DELAY_FAKTOR);
set_SCL();
delay(20*DELAY_FAKTOR);
set_SDA();
delay(20*DELAY_FAKTOR);
}
/*-----------------------------------------------------------------------*/
void E2Bus_send(unsigned char value) // send Byte to E2 Interface
{
unsigned char i;
unsigned char maske = 0x80;
    for (i=8;i>0;i--)
        {
            clear_SCL();
            delay(10*DELAY_FAKTOR);
            if ((value & maske) != 0)
                {set_SDA();}
            else
                {clear_SDA();}
            delay(20*DELAY_FAKTOR);
            set_SCL();
            maske >>= 1;
            delay(30*DELAY_FAKTOR);
            clear_SCL();
        }
set_SDA();
}
/*-----------------------------------------------------------------------*/
unsigned char E2Bus_read(void) // read Byte from E2 Interface
{
unsigned char data_in = 0x00;
unsigned char maske = 0x80;
    for (maske=0x80;maske>0;maske >>=1)
        {
            clear_SCL();
            delay(30*DELAY_FAKTOR);
            set_SCL();
            delay(15*DELAY_FAKTOR);
            if (read_SDA())
            {data_in |= maske;}
            delay(15*DELAY_FAKTOR);
            clear_SCL();
        }
return data_in;
}
/*-----------------------------------------------------------------------*/
char check_ack(void) // check for acknowledge
{
unsigned char input;
delay(30*DELAY_FAKTOR);
set_SCL();
delay(15*DELAY_FAKTOR);
input = read_SDA();
delay(15*DELAY_FAKTOR);
if(input == 1) return NAK;
else return ACK;
}
/*-----------------------------------------------------------------------*/
void send_ack(void) // send acknowledge
{
clear_SCL();
delay(15*DELAY_FAKTOR);
clear_SDA();
delay(15*DELAY_FAKTOR);
set_SCL();
delay(30*DELAY_FAKTOR);
clear_SCL();
set_SDA();
}
/*----------------------------------------------------------------------*/
void send_nak(void) // send NOT-acknowledge
{
clear_SCL();
delay(15*DELAY_FAKTOR);
set_SDA();
delay(15*DELAY_FAKTOR);
set_SCL();
delay(30*DELAY_FAKTOR);
clear_SCL();
set_SDA();
}
/*---------------------------------------------------------------------*/
void delay(unsigned int value) // delay- routine
{ while (--value != 0); }
/*---------------------------------------------------------------------*/
void set_SDA(void)
{ SDA = 1; } // set port-pin (SDA)
void clear_SDA(void)
{ SDA = 0; } // clear port-pin (SDA)
unsigned char read_SDA(void)
{ 
    if (SDA = 1) return SDA;     // read SDA-pin status
} 
void set_SCL(void)
{ SCL = 1; } // set port-pin (SCL)

void clear_SCL(void)
{
SCL = 0;    //clear SCL
}

unsigned char ee891_status(void)
{
unsigned char stat_ee891;
E2Bus_start(); // start condition for E2-Bus
E2Bus_send(0x71); // main command for STATUS request
    if (check_ack()==ACK)
        {   stat_ee891 = E2Bus_read(); // read status byte
            send_ack();
            checksum = E2Bus_read(); // read checksum
            send_nak(); // send NAK ...
            E2Bus_stop(); // ... and stop condition to terminate
            if (((stat_ee891 + 0x71) % 256) == checksum) // checksum OK?
                return stat_ee891;
        }
return 0xFF; // in error case return 0xFF
}

unsigned int co2_read (void)
{
co2 = -1; // default value (error code)
E2Bus_start();
E2Bus_send(0xC1); // MW2-low request
if (check_ack()==ACK)
    {
        co2_low = E2Bus_read();
        send_ack();
        checksum = E2Bus_read();
        send_nak(); // terminate communication
        E2Bus_stop();
        if (((0xC1 + co2_low) % 256) == checksum) // checksum OK?
            {
                E2Bus_start();
                E2Bus_send(0xD1); // MW2-high request
                check_ack();
                co2_high = E2Bus_read();
                send_ack(); // terminate communication
                checksum = E2Bus_read();
                send_nak();
                E2Bus_stop();
                if (((0xD1 + co2_high) % 256) == checksum) // checksum OK?
                    {
                        co2_ee891=co2_low+256*co2_high;
                        //yes->calculate temperature
                       // co2 =((float)co2_ee891/100) - 273.15;
                        // overwrite default (error) value
                    }
            }
        E2Bus_stop();
    }
return co2;
}

[paulfjujo]

oula!

tu l'as recupéré ou ton code ?

unsigned char read_SDA(void)
{ 
    if (SDA = 1) return SDA;     // read SDA-pin status
}

Il y a deja une grosse anomalie , car il n'y a pas de retournement de fonction de la pin utilisée
pour la lecture de SDA
SDA qui est auparavant utilisée en sortie !

de plus le test doit s'ecrire
if (SDA==1)
return 1 ;
else
return 0;

sinon tu affecte constamment 1 à SDA .

Ou sont definis SCL et SDA ?

Je n'ai pas verifié le reste du code..

[invite0e0d6f65]

J'ai repris ce code d'une note d'application trouvée sur le site d'E+E, la marque de mon capteur. Si tu veux des infos concernant ce capteur et le protocole d'ailleurs, c'est ici.

Le code que je t'ai envoyé est en fait e2_interface.c et la définition de SDA et SCL est faite dans e2_interface.h où sont prototypées mes fonctions.

[paulfjujo]

le site du fabricant est clair :
// adapt this code for your target processor !!!

tu n'as plus qu'à t'inspirer de routines de Soft I2C pour parfaire la routine de lecture data.
voir le lien donné par Amoniaque Tutorial...
On y voit la notion de basculement Entree/sortie de SDA par manipulation du TRISB (registre de direction)
suivant ecriture ou lecture data.

A toi de jouer .

[invite0e0d6f65]

Certes il faut adapter le code pour la lecture. Mais ça cela concerne la partie software. Pour l'instant je ne me suis pas réellement attaché à régler les problèmes de cette partie. Par ailleurs au niveau Hardware, dois-je câbler le bus sur un port I²C de mon PIC ou bien est-ce que je peux brancher mon bus sur n'importe quel port pour avoir mon bus à l'état haut au repos ?

[paulfjujo]

Tu peux conserver les pins B1 et B2 sans utiliser l'I2C hardware..
ou d'autres si tu en as envie !!
Mais tu ne peux pas separer le Hardware et le Software
puisque dans ton main
tu initialise les 2 pins B1 et B2 en sorties et au niveau Zero !
voir post #8

puis tu rentre de suite dans la routine
dummy = ee891_status() ; // Démarre une mesure
qui modifie aussi l'etat des pins!

Fait un simple test pour t'en assurer ...

void main()
{
OSCCON = 0x62 ;
ANSELB=0;
TRISB = 0x00 ;    // en sortie
LATB = 0X06 ;    // B1 =1 B2=1

while(1);

}

La tu peux verifier si tes signaux sont à 1 au repos !
A moins que le device CO2 les ecrabouilles à zero...

[invite0e0d6f65]

Par rapport à ta dernière réponse, j'ai une petite question tout de même.

Lorsqu'un port est en sortie LATx = PORTx, jusque là sommes-nous d'accord ? Si oui le fait de faire LATB = 0x06 va mettre mes pins RB1 et RB2 au niveau haut, soit 5V. Mais alors dans ce cas, à quoi serve les résistances de pull up ?

Et j'ai fait des essais, l'impédance du capteur de CO2 est assez importante pour ne pas écraser le bus au niveau bas.

[paulfjujo]

bonjour,

...à quoi serve les résistances de pull up ?

a maintenir un niveau haut,lorsqu'on commute la pin en mode input.
et donc inverser le sens de dialogue entre maitre et esclave.

[invite0e0d6f65]

Concrètement la résistance de pull up n'est utile que sur la ligne SDA du bus... C'est contradictoire avec ce qui est précisé dans ce document.

Et encore je vais faire un essaie pour voir si même en entrée la tension ne chute pas quand SDA est en entrée.

[invite3ad61e0c]

Salut!

Tu peux toujours essayer comme ça :