Répondre à la discussion
Affichage des résultats 1 à 4 sur 4

PIC Hi tech C : Créer un fichier .h et .c pour créer une petite librairie



  1. #1
    *Baby*

    PIC Hi tech C : Créer un fichier .h et .c pour créer une petite librairie


    ------

    Bonjour,

    Le problème auquel je me heurte est presque résumer dans le titre.

    En fait je dispose de mon code qui se trouve dans un unique fichier, fonction pour LCD, pour capteur ... et je voudrait créer des .h, .c pour le capteur par exemple.

    Voici mon code complet avec en orange ce qui est a mettre dans le .h, .c. Es ce que quelqu'un pourrait me dire quoi mettre dans ces 2 fichiers, car après de nombreuses tentatives, la compilation échoue en me disant que les élément tel que RB..., RA.. n'ont pas étaient définies alors que je l'ai bien fait.

    //---------------------------------E/S et variables generales---------------------

    #include <htc.h>
    #include "delay.h"



    // Define des variables LCD

    #define LCD_DATA PORTB
    #define LCD_RS RA1
    #define LCD_EN RA2


    // Define validation LCD
    #define LCD_STROBE() ((LCD_EN = 1),(LCD_EN=0))


    // Protoypes fonctions LCD
    void LCD_INIT(); // Fonction d'initialisation du LCD en mode 4 bits, LCD 2x16, matrice caractère 5x8

    void clear(); // Efface l'écran

    void lcd_write(unsigned char data); // Fonction qui prend en paramettre les données sur 8bits et les écrits en mode 4bits dans le LCD

    void write_char_at(char caractere, char at); // Ecrit le caractère "caractere" à l'emplacement "at"
    void write_char(char caractere); // Ecrit le caractère "caractere" à l'emplacement actuel du curseur

    void write_at(const char* texte, char at); // Ecrit la chaine "texte" à l'emplacement "at"
    void write(const char* texte); // Ecrit la chaine "teste" à l'emplacement actuel du curseur



    unsigned long int somme[10];












    //************************* 1-Wire : DS18B20 ****************************** *********
    #define D_PIN RB4 // D_PIN est la pin ou est connecté le 1-Wire bus
    #define D_TRIS TRISB4 // TRIS de la pin D_PIN
    #define D_RiseSpace 10 // Temps de monté à l'état haut du bus + Temps minimum entre 2 commandes


    bit D_Data; // Variable de type bit qui doit être déclarée en globale



    // Protoype des fonctions implémentées
    void D_Reset(void); // Reset le capteur
    void D_Write(char Data); // Ecrit l'octet Data
    char D_Read(void); // Lit un octet du capteur et le stocke dans D_Read
    long int GetTemp();
    //****************************** ****************************** ****************





    //******************** Déclaration de structure ****************************** ***
    typedef union
    {
    unsigned char octet;
    struct
    {
    unsigned bit0:1;
    unsigned bit1:1;
    unsigned bit2:1;
    unsigned bit3:1;
    unsigned bit4:1;
    unsigned bit5:1;
    unsigned bit6:1;
    unsigned bit7:1;
    } bits;
    } variable;



    typedef union
    {
    unsigned short int doctet;
    struct
    {
    unsigned bit0:1;
    unsigned bit1:1;
    unsigned bit2:1;
    unsigned bit3:1;
    unsigned bit4:1;
    unsigned bit5:1;
    unsigned bit6:1;
    unsigned bit7:1;
    unsigned bit8:1;
    unsigned bit9:1;
    unsigned bit10:1;
    unsigned bit11:1;
    unsigned bit12:1;
    unsigned bit13:1;
    unsigned bit14:1;
    unsigned bit15:1;
    } bits;
    } variable2;
    //****************************** ****************************** ****************















    //-------------------------------Fonction principale------------------------------



    void main(void)
    {
    // Initialisation des pattes du microcontroleur

    PORTA=0;
    PORTB=0;
    TRISA = 0b11110001; // RA0 = AN0 => Entrée Ana => TRISA.0 = 1
    TRISB = 0b01000000;


    ANSEL = 0b00000001; // Configure AN0 en entréé ANA, le reste en en entrée TOR

    ADCON0=0b01000000; // Configuration de l'oscillateur et sélection du channel AN0

    ADCON1=0b10000000; // Configuration de l'oscillateur + tension de référence


    LCD_INIT();

    write_at("Temperature :", 0x00);
    write_char_at(0b11011111, 0x44); // °
    write_char(67); // C





    // Déclaration des variables utilisées

    unsigned long int resultat=0;
    unsigned long int temp=0;
    char dizaines = 0;
    char unites =0;
    char dizieme =0;
    char i = 0;
    char b = 0;



    while(1)
    {
    RB5=1;
    if(RB6 == 1)
    {

    for(i=0;i<10;i++)
    {
    resultat=0;



    ADON=1; // Mise en route du convertisseur Ana to Dec
    DelayMs(1);
    GODONE=1; // Lancement de la conversion
    while(GODONE); // Wait conversion done



    // Lecture résultat

    resultat=ADRESL; // Get the 8 bit LSB result
    resultat += (ADRESH << 8); // Get the 2 bit MSB result

    somme[i]=resultat;

    resultat=0;
    for(b=0;b<10;b++)
    {
    resultat+=somme[b];
    }
    resultat=resultat/10;



    temp=1020*resultat;// 5000 sans aop (1000*0.939)
    temp=(temp/1024);


    dizaines = 48+(temp/100);
    unites = 48+(temp%100)/10;
    dizieme = 48+(temp%10);


    // Rafraichissement résultat

    write_char_at(dizaines, 0x40); // Dizaines
    write_char(unites); // unites
    write_char(46); // .
    write_char(dizieme); // dizieme


    DelayS(1);
    DelayS(1);

    }

    }
    else if (RB6 == 0)
    {





    temp=GetTemp();
    temp=temp*1250/2000;

    //DelayS(1);



    dizaines = 48+(temp/100);
    unites = 48+(temp%100)/10;
    dizieme = 48+(temp%10);


    // Rafraichissement résultat

    write_char_at(dizaines, 0x40); // Dizaines
    write_char(unites); // unites
    write_char(46); // .
    write_char(dizieme); // dizieme





    }













    }


    }








    // Fonction qui prend en paramettre les données sur 8bits et les écrits en mode 4bits dans le LCD
    void lcd_write(unsigned char data)
    {
    LCD_DATA = ( ( data >> 4 ) & 0x0F ); // On sélectionne les 4 bits de poid fort
    LCD_STROBE();
    DelayUs(50);
    LCD_DATA = ( data & 0x0F ); // Puis on sélectionne les 4 bits de poid faible
    LCD_STROBE();
    DelayUs(50);
    }



    // Fonction d'initialisation du LCD en mode 4 bits, LCD 2x16, matrice caractère 5x8
    void LCD_INIT()
    {

    DelayMs(50); // Temps d'attente pendant le démarrage du LCD

    LCD_RS = 0;

    LCD_DATA = 0b00000010; // Set Function (Initialisation) : Mode 4bits + Afficheur 1 lignes (à ce stade on ne peut que utiliser les 4bits de données de poid fort)
    LCD_STROBE();
    DelayUs(50);


    lcd_write(0b00101000); // On réinitialise, mais cette fois en sélectionnant : mode 4 bits + Afficheur 2 lignes + matrice 5x8

    lcd_write(0b00000110); // Entry mode set (Mode de décalage) : Décalage curseur vers la droite après écriture et pas de décalage affichage

    lcd_write(0b00001100); // Display On/Off control (Afficheur On/Off, curseur et clignotement) : Afficheur on + curseur invisible + fixe

    }



    // Ecrit le caractère "caractere" à l'emplacement "at"
    void write_char_at(char caractere, char at)
    {
    LCD_RS = 0;
    lcd_write(0b10000000 | at); // Set DDRAM address : Emplacement "at"


    LCD_RS = 1;
    lcd_write(caractere); // Affichage du caractère "caractere"
    }



    // Ecrit le caractère "caractere" à l'emplacement actuel du curseur
    void write_char(char caractere)
    {
    LCD_RS = 1;
    lcd_write(caractere); // Affichage du caractère "caractere"
    }


    // Efface l'écran
    void clear()
    {
    LCD_RS = 0;
    lcd_write(1); // Efface
    DelayMs(1);
    DelayMs(1);
    }



    // Ecrit la chaine "texte" à l'emplacement "at"
    void write_at(const char* texte, char at)
    {

    char i =0;

    LCD_RS = 0;
    lcd_write(0b10000000 | at); // Set DDRAM address : Emplacement "at"



    LCD_RS = 1;

    do
    {
    lcd_write(texte[i]); // Affichage le caractère i de la chaine texte
    i++;
    }while(texte[i]!='\0');

    }




    // Ecrit la chaine "teste" à l'emplacement actuel du curseur
    void write(const char* texte)
    {

    char i =0;


    LCD_RS = 1;

    do
    {
    lcd_write(texte[i]); // Affichage le caractère i de la chaine texte
    i++;
    }while(texte[i]!='\0');

    }















    long int GetTemp()
    {
    char lsb = 0;
    char msb = 0;
    variable lsb1;
    variable msb1;
    variable2 msblsb;

    //1 - Configuration :
    D_Reset(); // Reset
    D_Write(0xCC); // Commande ROM : "Skip ROM". permet d'envoyer la commande qui va suivre à tous les composants sur le bus
    D_Write(0x4E); // Commandes de fonctions : "Write scratchpad". Permet d'écrire dans l'ordre : TH, TL, Configuration Register
    D_Write(0b00011001); // Température haute (TH) : Valeur non significative puisque on utilise pas les alarmes
    D_Write(0b11110101); // Température basee (TL) : Valeur non significative puisque on utilise pas les alarmes
    D_Write(0b01111111); // Configuration Register : R0=R1=0 => Résolution 9 Bits
    DelayMs(1);


    //2 - Conversion :
    D_Reset(); // Reset
    D_Write(0xCC); // Commande ROM : "Skip ROM". permet d'envoyer la commande qui va suivre à tous les composants sur le bus
    D_Write(0x44); // Commandes de fonctions : "Convert T" (0x44). Cette commande permet de lancer une convesion de température.
    DelayS(1); // Temps mis pour la conversion (Voir doc)

    //3 - Récupération du résultat :
    D_Reset(); // Reset
    D_Write(0xCC); // Commande ROM : "Skip ROM". permet d'envoyer la commande qui va suivre à tous les composants sur le bus
    D_Write(0xBE); // Commandes de fonctions : "Read SCRATCHPAD" (0xBE). Lit les 9 octets dans l'ordre LSB,MSB, ...
    lsb = D_Read(); // Lecture de LSB
    msb = D_Read(); // Lecture de MSB
    D_Reset(); // Reset car on a pas besoin de la suite


    //Permet de concaténer LSB et MSB dans la variable temp
    lsb1.octet = lsb;
    msb1.octet = msb;
    msblsb.doctet = 0;

    msblsb.bits.bit0=lsb1.bits.bit 0;
    msblsb.bits.bit1=lsb1.bits.bit 1;
    msblsb.bits.bit2=lsb1.bits.bit 2;

    msblsb.bits.bit3=lsb1.bits.bit 3;
    msblsb.bits.bit4=lsb1.bits.bit 4;
    msblsb.bits.bit5=lsb1.bits.bit 5;
    msblsb.bits.bit6=lsb1.bits.bit 6;
    msblsb.bits.bit7=lsb1.bits.bit 7;

    msblsb.bits.bit8=msb1.bits.bit 0;
    msblsb.bits.bit9=msb1.bits.bit 1;
    msblsb.bits.bit10=msb1.bits.bi t2;


    return msblsb.doctet;


    }
















    //****************************** ****************************** ****************
    //D_Reset -- Resets the 1-wire bus and checks for presence & short cct
    //****************************** ****************************** ****************
    void D_Reset(void)
    {
    //-- On relache le bus à1 avant de procéder au reset
    D_TRIS=1; // Mise en entrée = bus à 1


    //-- Début du reset
    D_PIN=0;
    D_TRIS=0; //-- Mise du bus à 0 pour démarrer le reset

    DelayUs(100); //-- Pulse d'au moins 480µs
    DelayUs(100);
    DelayUs(100);
    DelayUs(100);
    DelayUs(100);

    D_TRIS=1; //-- Relache le bus à 1
    DelayUs(60); //-- Après 60µs ou maximum le capteur témoigne de sa présence en mettant le bus à 0

    // On pourrait vérifier que le capteur envoit bien le pulse de présence

    DelayUs(100); // On attend au moins 480-60µs
    DelayUs(100);
    DelayUs(100);
    DelayUs(100);
    DelayUs(30);

    DelayUs(D_RiseSpace); //-- Temps de relachement de monté du bus à 1 + temps d'attente entre 2 opérations
    }
    //******************END OF D_Reset





    //****************************** ****************************** ****************
    // D_Write
    //****************************** ****************************** ****************
    void D_Write(char Data)
    {
    char count=8;
    for(;count>0;count--)
    {
    D_Data= Data & 0x01; //-- Récupère le LSB

    //-- Ecrit le bit sur le port
    D_PIN=0;
    D_TRIS=0; //-- Met le bus à 0
    // DelayUs(5); //-- Time slot : Attente de 1 à 15µsyyYYYYYYYYYYYYYYYYYYYYYYYY
    D_TRIS=D_Data; //-- Envoi le bit sur le port
    DelayUs(60); //-- Fini le Time slot
    D_TRIS=1; //-- Relache le port à 1

    //-- Attente entre l'envoi de 2 bits
    DelayUs(D_RiseSpace);

    //-- Preparation du prochain bit
    Data=Data>>1;
    }
    DelayUs(D_RiseSpace); //-- Rise time + Min Space
    }
    //******************END OF D_Write









    //****************************** ****************************** ****************
    // D_Read
    //****************************** ****************************** ****************
    char D_Read(void)
    {
    char count=8,data=0;
    for(;count>0;count--)
    {
    //-- Lit le bit sur le port
    D_PIN=0;
    D_TRIS=0; //-- Lower the port
    DelayUs(5); //-- Time slot start time
    // DelayUs(3); //-- Time slot start time YYYYYYYYYYYYYYYYYYYYY
    D_TRIS=1; //-- Release port for reading
    // DelayUs(5); //-- Get close to center of timeslot
    DelayUs(8); //-- Get close to center of timeslot
    D_Data=D_PIN; //-- Read the data bit in
    DelayUs(55); //-- Finish the timeslot



    //-- Met le bit dans le byte
    data = data >> 1; //-- Shift previous bits across
    if(D_Data==1) //-- If data was high then add High bit to data
    {
    data +=0x80;
    }

    //-- Attente entre la lecture de 2 bits
    DelayUs(D_RiseSpace); //-- Recovery time between Bits
    }
    DelayUs(D_RiseSpace); //-- Rise time + Min Space
    return(data);
    }
    //******************END OF D_Read

    Merci d'avance.

    -----

  2. Publicité
  3. #2
    Jack
    Modérateur

    Re : PIC Hi tech C : Créer un fichier .h et .c pour créer une petite librairie

    Pourquoi veux-tu faire cette séparation?

    Sinon, tu peux toujours mettre toutes les définitions et déclarations dans le .h et le reste (à partir de la fonction main) dans le .c.

    Dans mon_fichier.h, ne pas oublier d'éviter les inclusions multiples. Par exemple:
    Code:
    #ifndef _MON_ENTETE_
    #define _MON_ENTETE_
     
    ...  // définitions et déclarations
     
    #endif
    et dans le mon_fichier.c, ne pas oublier de commencer par:
    Code:
    #include "mon_fichier.h"
    A+

  4. #3
    *Baby*

    Re : PIC Hi tech C : Créer un fichier .h et .c pour créer une petite librairie

    Pourtant c'est bien ce que j'ai fait. Je n'ai pas mis le "ifndef" mais je ne l'ai pas déclarer 2 fois.

    Es ce que tu pourrais essayer de compiler le code sans modifications puis en mettant les parties oranges dans des .h, .c et me montrer exactement ce que tu as mis dedans ?

  5. #4
    *Baby*

    Re : PIC Hi tech C : Créer un fichier .h et .c pour créer une petite librairie

    Une histoire à devenir fou, je reteste ce matin, ça marche parfaitement.

    No comment.

    @+

  6. A voir en vidéo sur Futura
  7. Comparatifs

    Gagnez du temps et de l'argent grâce à nos comparatifs de produits. Parmi nos sujets :

Discussions similaires

  1. Créer une petite soufflerie pour automobile
    Par Spykou dans le forum TPE / TIPE et autres travaux
    Réponses: 2
    Dernier message: 01/05/2010, 16h53
  2. Créer un fichier météo pour logiciel comfie
    Par ther_lotfi dans le forum Habitat bioclimatique, isolation et chauffage
    Réponses: 2
    Dernier message: 15/02/2010, 13h06
  3. Réponses: 1
    Dernier message: 21/09/2009, 16h26
  4. Programmation C++ avec la librairie ITK. Comment créer une image en couleur ?
    Par trankilboy dans le forum Logiciel - Software - Open Source
    Réponses: 0
    Dernier message: 14/09/2009, 01h43
  5. Creer une liste sur mathématica à partir d'un fichier excel
    Par paradise295 dans le forum Logiciel - Software - Open Source
    Réponses: 0
    Dernier message: 30/05/2008, 17h04
Découvrez nos comparatifs produits sur l'informatique et les technologies.