Création header pour interfacer un Capteur de taux de CO2 avec PIC18F45K22

[invite0e0d6f65]

Bonjour à tous !

Décidément je suis très actif sur le forum ces dernières semaines, j'espère que vous voudrez bien de nouveau m'apporter votre aide. Et par avance, je tiens à remercier tout ceux qui m'ont aidé et m'aideront de nouveau. Venons en au fait !

Pour mon projet de fin d'étude, je dois pouvoir lire la mesure d'un capteur de taux de CO2 depuis mon PIC18F45K22. Voici la référence de ce capteur EE891. Ce capteur à une sortie numérique basée sur le protocole E2 Interface. Ce protocole est très très similaire à l'I2C mais le problème est que mon PIC18F45K22 ne connait pas ce protocole.

Sur le site de la marque du capteur, il y a une note d'application présentant un exemple d'utilisation de l'E2 Interface. Mais personnellement je n'ai jamais créer d'header en C, du coup cette tâche reste relativement flou pour moi. Par conséquent j'ai fait des recherches sur le net et je me suis appuyé sur une petite vidéo présentant cette tâche.

Sous MPLAB X IDE, j'ai donc créé un nouveau projet. Ce projet est pour le moment composé de main.c, e2_interface.c et e2_interface.h dont voici leur code respectif :

main.c

#include <p18f45k22.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


void main()
{

}

e2_interface.c

#include "e2_interface.h"

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
{
bit 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)
bit read_SDA(void)
{ return SDA; } // read SDA-pin status
void set_SCL(void)
{ SCL = 1; } // set port-pin (SCL)
void clear_SCL(void)
{ SCL = 0; } // clear port-pin (SCL)

e2_interface.h

#include "e2_interface.h"

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
{
bit 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)
bit read_SDA(void)
{ return SDA; } // read SDA-pin status
void set_SCL(void)
{ SCL = 1; } // set port-pin (SCL)
void clear_SCL(void)
{ SCL = 0; } // clear port-pin (SCL)

Donc j'aimerais savoir si quelqu'un peut m'indiquer si je suis bien engagé, me donner des conseils ou tout autres éléments d'aide svp ?
-----

[Seb.26]

Tu as posté 2 fois le fichier .c

En gros, un header contient les définitions nécessaires pour utiliser ce qui est dans le .c (ou dans le .lib)
- prototype des fonctions
- variables partagées
- enum
- #define
- ...etc

[invite0e0d6f65]

J'ai commis une erreur lors des copier/coller de mes codes.

e2_interface.h

/***************************************************************************/
// definitions
#define DELAY_FAKTOR 10 // setup clock-frequency
#define ACK 1 // define acknowledge
#define NAK 0 // define not-acknowledge
#define SDA  PORTAbits.RA1 
#define SCL PORTAbits.RA2
/***************************************************************************/
// variables
unsigned char co2_low;
unsigned char co2_high;
unsigned char checksum_03;
unsigned int rh_ee03= 0;
unsigned int temp_ee03= 0;
int co2 = 0 ;
/***************************************************************************/
// fonctions
char check_ack(void);
void send_ack(void);
void send_nak(void);
void E2Bus_start(void); // send start condition
void E2Bus_stop(void); // send stop condition
void E2Bus_send(unsigned char);
void set_SDA(void);
void clear_SDA(void);
char read_SDA(void);
void set_SCL(void);
void clear_SCL(void);
unsigned char E2Bus_read(void); // read one byte from E2-Bus
void delay(unsigned int value);
/***************************************************************************/

Veuillez m'excuser pour cette erreur.

[invite0e0d6f65]

@Seb.26 : penses-tu que mon projet est bien structuré ? et j'ai une autre petite question : est-il possible de créer des fonctions de type boolean en C pour PIC ? (boolean nomfonction() )

[A voir en vidéo sur Futura]

[Seb.26]

@Seb.26 : penses-tu que mon projet est bien structuré ? et j'ai une autre petite question : est-il possible de créer des fonctions de type boolean en C pour PIC ? (boolean nomfonction() )

C'est (presque) interdit de mettre une variable dans un .h !!!
-> un .h est destiné à être inclut x fois (partout où on en a besoin), donc il faut déclarer les variables dans le .c et faire un extern dessus dans le .h
ceci seulement pour les variables qui doivent être visibles de l’extérieur.

Non, pas de type boolean en C, tu dois utiliser un unsigned char ( 0 ou 1 ) pour cela.

[Seb.26]

my 2 cents :

> Ne jamais utiliser le type int en embarqué ... toujours utiliser char / short / long qui eux sont standardisé "dans la pratique" bien que les références du C le soient moins.
> le type int donne du code non portable car la talle allouée varie selon le compilo et le CPU, de plus, c'est prendre l'habitude de gaspiller de la RAM, mieux vaut se poser la question à chaque variable de savoir ce que l'on va mettre dedans.

[invite0e0d6f65]

Merci pour ton aide Seb.26. Aujourd'hui j'ai fait quelque modification et pour l'instant tout compile ! En espérant que cela marche ...

Par contre maintenant j'ai une nouvelle petite question. Si tu t'es un peu penché sur le code d'e2_interface.c hier tu t'es certainement rendu compte qu'en fait les différentes fonctions sont faites pour réaliser le protocole E2 Interface conçu par la marque de mon capteur de CO2. Pour simuler l'envoie des trames ils utilisent une fonction delay et un facteur de delay. Ceci ayant uniquement pour but de temporiser des niveaux haut ou bas sur les pins concernées. Mais voilà j'aimerais pouvoir mesurer et maitriser ces delay.Car en effet mon capteur de CO2 ne supporte qu'une fréquence de communication comprise entre 500 et 5000hz d'après le datasheet.

En ayant fait quelques recherches sur le sujet, j'ai retrouvé d'ancien Topic où tu intervenais c'est pourquoi je pense que tu pourras m'être d'une aide. Voilà les données :

J'utilise mon PIC18F45K22 à une fréquence de 8MHz, fréquence venant de mon oscillateur interne. Si je ne me trompe pas, mon micro tourne donc à 2MIPS. Soit 1 instructions toute les 0,5µs. (Corrige moi si je me trompe). Si je veux une fréquence de com' de 5000hz, j'ai une période de 1/5000 soit 200µs... Mais je ne comprends pas trop comment créer cette temporisation. Pourrais-tu me donner une méthode à suivre stp ?

Par avance merci.