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