probleme d'adressage registre SFR pour microprocesseur 80c515

**malabar969** · 27/05/2011, 21h00

Bonjour,

Je suis débute dans la programmation en C.
Dans le cadre d'un exercice, je dois programmer un microprocesseur 80c515 en langae C, avec 3 modules. un LCD I2C (1), un clavier 8 boutons I2C (2)et un module a LED(barregraphe)I2C (3).L'un des problème que je rencontre est que lorsque je branche les 3 modules sur le même port ( port 5 du microprocesseur) le module barregraphe bloque les deux autres. Donc je dois mettre le module barregraphe sur un autre port ( port 4 du microprocesseur), séparément cela fonctionne mais ensemble je n'arrive pas à définir deux port différent, le logiciel plante.les modules sont conecter au ports 5.0 SDA et 5.1 CLS.
la fonction utiliser est sfr at 0xf8 Piic; // Piic = Port 5 dans le fichier iic.h .
J'ai chercher la fonction at , sans aucun résultat.

Merci d'avance

**malabar969** · 27/05/2011, 21h04

voici les fichiers

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
/************************************************************************/
/*    Titre :    SW IIC_Header                                          */
/*    Auteur :   ACMC/hpo                                               */
/*    Date :     06/04                                                  */
/*    Software:  SDCC                                                   */
/*    Hardware:  Flash PSD1								 */
/*    Remarque : SDA est Piic B0 / SCL est Piic B1                      */
/*                                                                      */
/*              Fonctions I2C:                                          */
/*              I2C_INIT ->        Initialise B0 et B1,                 */
/*                                 réinitialise Bit0 en byte d'ETAT     */
/*              I2C_START->        Génère la séquence de démarrage      */
/*              I2C_STOP ->        Génère la séquence d'arrêt           */
/*              I2C_ACK  ->        Vérifie la condition ACK (SDA=0)     */
/*              IIC_ACK_SEND ->    Envoie signal Ackknowledge           */
/*              IIC_NO_ACK_SEND -> Envoie signal NO-Ackknowlede         */
/*              I2C_SEND_BYTE  ->  Maître envoie un byte à l'esclave    */
/*                                 et vérifie ACK                       */
/*              I2C_RECEIVE   ->   Maître reçoit un byte de l'esclave   */
/************************************************************************/
 
// Définitions nécessaires
sfr at 0xf8 Piic;                   // Piic = Port 5
 
 
//#define Piic&0xf8;
 
 
 
#define SDA 0                       // Piic bit 0 = SDA
#define SCL 1                       // Piic bit 1 = SCL
 
 
 
unsigned char adr_lcd = 0x74;       // Adresse LCD
 
unsigned char adr_temp_sens = 0x9e; // Adresse capteur de température 1001|1110
unsigned char adr_rtc = 0xd0;       // Adresse horloge temps réel 1101|0000
unsigned char STATUS = 0x00;        // Registre d'état, bit 0=1 pour erreur IIC
unsigned char IIC_test;
unsigned char in;
 
/********************************************************************
                   Délai d'attente
********************************************************************/
 
void wait_IIC(unsigned int us)
{
   while(us) us--;
}
 
/********************************************************************
                   INIT de I2C
********************************************************************/
 
void IIC_INIT(void)
{
 
   Piic |= 0x03;              // SCL =SDA = 1
   wait_IIC(5);               // Temps de l'horloge
   STATUS &= 0xfe;            // Réinitialiser bit d'état
}
 
 
/********************************************************************
                   Séquence de démarrage de I2C
********************************************************************/
 
void IIC_START(void)
{
   while(IIC_test != 0x03)          // SDA/SCL = 1 ?
   {
      IIC_test=0x00;
      Piic |= 0x03;                 // SDA = SCL = 1
      IIC_test = Piic;              // Charger Piic
      IIC_test =(IIC_test & 0x03);  // SDA/SCL positionné ?
   }
 
 
   // Condition de démarrage
   Piic &= 0xfe;           // SDA = 0
   wait_IIC(5);            // Temps de l'horloge
   Piic &= 0xfd;           // SCL = 0
   wait_IIC(5);            // Temps de l'horloge
}
 
 
/********************************************************************
                   Séquence d'arrêt de I2C
********************************************************************/
 
void IIC_STOP(void)
{
   Piic &= 0xfe;           // SDA = 0
   wait_IIC(5);            // Temps de l'horloge
   Piic |= 0x02;           // SCL = 1
   wait_IIC(5);            // Temps de l'horloge
   Piic |= 0x03;           // SDA = 1
   wait_IIC(5);            // Temps de l'horloge
}
 
/********************************************************************
                  Vérifier Acknowledge (SDA = 0?)
     si SDA différent de 0, mettre bit d'erreur sur ETAT
********************************************************************/
 
void IIC_ACK(void)
{
   STATUS = 0x00;             // Réinitialiser bit d'état
   Piic |= 0x03;              // SDA = 1 SCL = 1
   wait_IIC(5);               // Temps de l'horloge
 
   IIC_test = Piic;           // Charger Piic
   IIC_test = (IIC_test & 0x01);
   if(IIC_test==0x01)STATUS=1;
 
   Piic &= 0xfd;              // SCL = 0
   wait_IIC(5);
}
 
/********************************************************************
                  Envoyer Acknowledge 
********************************************************************/
 
void IIC_ACK_SEND(void)
{
   Piic &= 0xfe;           // SDA = 0
   Piic |= 0x02;           // SCL = 1
   wait_IIC(5);            // Temps de l'horloge
   Piic &= 0xfc;           // SCL = SDA = 0
}
 
/********************************************************************
                Envoyer NO-Acknowledge
********************************************************************/
 
void IIC_NO_ACK_SEND(void)
{
   Piic |= 0x03;           // SDA = SCL = 1
   wait_IIC(5);            // Temps de l'horloge
   Piic &= 0xfc;           // SDA = SCL = 0
 
}
 
/********************************************************************
     Envoyer 1 byte à l'esclave attendre ack
********************************************************************/
 
void IIC_SEND(unsigned char buffer)
{
   unsigned char test = 0x80,help,count1;
 
   Piic &= 0xfe;           // SDA = 0
 
   for(count1=0;count1<8;count1++)
   {
      help = buffer & test;         // Consulter buffer bit à bit si 1 ou 0
      if(help==test)  Piic = 0xfd;  // Si bit = 1, SDA = 1, sinon SDA = 0
      test = test/2;                // Bit suivant
      help = 0x00;                  // Réinitialiser help
      wait_IIC(5);                  // Attendre un peu
      Piic |= 0x02;                 // SCL = 1
      wait_IIC(5);                  // Temps de l'horloge
      Piic &= 0xfc;                 // SDA = SCL = 0
      wait_IIC(5);                  // Temps de l'horloge
   }                                // jusqu'à ce que les 8 bits soient envoyés
 
   IIC_ACK();                       // Vérifier ACK.
}
 
/********************************************************************
     Recevoir 1 byte de l'esclave sans ACK
********************************************************************/
 
unsigned char IIC_RECEIVE(void)
{
 
   unsigned char receive = 0x00,count2,bit1 = 0x80;
 
 
   for(count2=0;count2<8;count2++)
   {
      Piic |= 0x02;              // SCL = 1
      in = Piic;                 // Charger Piic
 
      if((in & 0x01)==0x01)      // Si SDA = 1,
      {
         receive |= bit1;        // Bit en "receive" = 1
      }else receive |= 0x00;     // Si pas de bit en "receive" = 0
      wait_IIC(5);               // Temps de l'horloge
      Piic &= 0xfd;              // SCL = 0
      wait_IIC(5);               // Temps de l'horloge
      bit1 = bit1/2;             // Bit suivant
   }                             // jusqu'à ce que les 8 bits aient été reçus
 
   return receive;               // Retour avec receive
}

**PIC16F877A** · 28/05/2011, 04h32

bonjour

je connais pas le 80c512 je programme que les PIC je ne sais pas si ma réponse va t'aider

le registre "SFR" c'est un pointeur on l'utilise pour l'adressage indirecte et qu'il marche toujour avec le registre "INDF" pour récupéré la donnée pointu par le registre "SFR", ce registre ne pointe que dans la mémoire de micro elle meme et qu'il na rien avoir avec les composent externe voir exemple

unsigned data;

SFR = 0x87 ; //entrer l'adresse de la variable que tu veux la lire
data = INDF ; //récupération de la donnée pointu par le registre "SFR"

/* ou */
INDF = 0x00 ; //on peut aussi l'utiliser pour initialiser nos variables

je ne sais pas ce qu'il fait ce registre avec l'I2C dans ton code la

et pour les définitions

// Définitions nécessaires
sfr at 0xf8 Piic; // Piic = Port 5

ici ce qui'est claire pour moi est que "0xf8" l'adresse de ton port "PORT5" et le nom "piic" = (port i2c) au lieu d'utiliser le vrais nom de ton port5, cette définition vous aidera en cas vous changer le port, change seulement l'adresse "0xf8" au lieu de modifier tous le code et pour "sfr at" j ne sais rien mais si tu peux essayer avec

#define piic port5 ; /*ici tu peux utilise soit le nom soit d'adresse "0xf8" de ton port*/

#define SDA piic,0 ;
#define SCL piic,1 ;

et dans ton code je ne vois au qu'une ligne parle de configuration de pins ? exemple pour

/********************************************************************
Vérifier Acknowledge (SDA = 0?)
si SDA différent de 0, mettre bit d'erreur sur ETAT
********************************************************************/

void IIC_ACK(void)
{
STATUS = 0x00; // Réinitialiser bit d'état
Piic |= 0x03; // SDA = 1 SCL = 1
wait_IIC(5); // Temps de l'horloge

IIC_test = Piic; // Charger Piic
IIC_test = (IIC_test & 0x01);
if(IIC_test==0x01)STATUS=1;

Piic &= 0xfd; // SCL = 0
wait_IIC(5);
}

ici je ne sais pas moi comment vous pouvez tester le signal s'il est 1 ou 0

normalement il faut configurer la pin SDA en entrer avec de la relacher (Piic |= 0x03; // SDA = 1 SCL = 1) et meme pour éviter les court-circuit sur la ligne SDA et SCL il faut configurer toujour les pins en entrer avant de les positionner a 1

j'espère mon message est bien exprimer pour toi

et bonne chance

**malabar969** · 28/05/2011, 09h26

Merci PIC16F877A,

Je vais essayer tes propositions.

Le i2C est un bus,lorsque l'on veut utiliser un module, on déclare sont adresse. Tout les modules ont une connexion SDA (serial data) et SCL(ligne d'horloge)et sont connecter, respectivement sur le port 5.0 et le port 5.1.

**malabar969** · 28/05/2011, 11h10

Bonjour PIC16F877A,
j'ai essayer tes solutions.Le logiciel crache toujours.
Si tu as une autre solution, je suis preneur.

Merci

**PIC16F877A** · 29/05/2011, 08h01

Le i2C est un bus,lorsque l'on veut utiliser un module, on déclare sont adresse. Tout les modules ont une connexion SDA (serial data) et SCL(ligne d'horloge)et sont connecter, respectivement sur le port 5.0 et le port 5.1.

je connais tres bien le bus i2C

mais mon grond probleme c'est que moi qui n'exprime pas bien ce que je veux dire par ce que je ne connais pas la langue français, je répete ce que j'ai déja dis pour le code de test de l'accusé de réception (Acknowledge) dans le bus i2c si l'envoi s'est bien passé l'un de tes modules répond par zéro sur la ligne SDA pour indéquer au métre (80c515) que la donnée est bien réçu , ton code peut marcher seulement avec les modules qui ne renvoi pas l'accusé comme le LCD par exemple et pas avec les autres modules, regarde

/********************************************************************
Vérifier Acknowledge (SDA = 0?)
si SDA différent de 0, mettre bit d'erreur sur ETAT
********************************************************************/

void IIC_ACK(void)
{
STATUS = 0x00; // Réinitialiser bit d'état
Piic |= 0x03; // SDA = 1 SCL = 1
wait_IIC(5); // Temps de l'horloge

IIC_test = Piic; // Charger Piic
IIC_test = (IIC_test & 0x01);
if(IIC_test==0x01)STATUS=1;

Piic &= 0xfd; // SCL = 0
wait_IIC(5);
}

dans ton code tu a met la ligne SDA a 1 = (5v) aumoment d'attender que l'un de tes module répond par zéro sur la meme ligne SDA a 0 = (masse) cela se traduire en français par (vous avez un court-circuit sur la ligne SDA) ici il faut relacher la ligne SDA c'est la résistance de tirage qui occupe de remettre automatiquement la ligne SDA a 1 pas ton micro, pour moi dans le microPIC j'ai le PORTX et un autre registre qui marche toujour avec le "TRISX" pour la configuration de pins "input or output" et pour relacher la ligne SDA dans mon cas je mes pas seulement PORTX,SDA = 1 ; parce que ça donne 5V sur la pin SDA mais je configurer avant la pin SDA en entrer TRISX,SDADIR = 1; puis PORTX,SDA = 1; comme ça le micro met la pin en contact ouvert pour laisse la résistance tire la ligne SDA a l'état haut (5v), j'ai chercher comment configurer les pins dans le datasheet de 80c515 tellement la doc est simple j'ai pas trouvé comment

si tu peux me donne un exemple de comment tu configurer les pins de ton micro en sortie ou en entrer, et pour le LCD/clavier/barregraphe tu utilise un convertisseur PCF ? et est ce que tu as des schéma ou c'est quoi les références de tous les composent i2c que tu les utilise dans tes modules ?

bonne chance avec ma mauvaise langue

**malabar969** · 30/05/2011, 23h23

Bonjour PIC16F877A,

Je te remercie pour ton aide.l'adresse pour la doc est www.mcls-modular.de .
j'ai changé sfr at 0xe8 Piic2; // Piic = Port 4 la premiére fois le logiciel me donnait des erreurs et maintenant ça fonctionne.

Encore un grand Merci PIC16F877A.
A Bientôt.
malabar969

**PIC16F877A** · 31/05/2011, 14h11

l'information donné pour l'i2c dans ton site n'est pas complète ni qu'un minimum code simple pour l'i2c

voici un beau code pour l'i2c http://en.wikipedia.org/wiki/I%C2%B2C

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
/* Hardware-Specific Support Functions That MUST Be Customized */
#define I2CSPEED  100
void I2CDELAY() {volatile int v; int i; for(i=0;i<I2CSPEED/2;i++) v;}
bool READSCL(void) {return 1;}  /* Set SCL as input and return current level of line, 0 or 1 */
bool READSDA(void) {return 1;}  /* Set SDA as input and return current level of line, 0 or 1 */
void CLRSCL(void) {} /* Actively drive SCL signal low */
void CLRSDA(void) {} /* Actively drive SDA signal low */
void ARBITRATION_LOST(void) {}
 
/* Global Data */
bool started = false;
 
void i2c_start_cond(void)
{
        /* if started, do a restart cond */
        if (started) {
                /* set SDA to 1 */
                READSDA();
                I2CDELAY();
                /* Clock stretching */
                while (READSCL() == 0)
                        ;  /* You should add timeout to this loop */
        }
        if (READSDA() == 0)
                ARBITRATION_LOST();
        /* SCL is high, set SDA from 1 to 0 */
        CLRSDA();
        I2CDELAY();
        CLRSCL();
        started = true;
}
 
void i2c_stop_cond(void)
{
        /* set SDA to 0 */
        CLRSDA();
        I2CDELAY();
        /* Clock stretching */
        while (READSCL() == 0)
                ;  /* You should add timeout to this loop */
        /* SCL is high, set SDA from 0 to 1 */
        if (READSDA() == 0)
                ARBITRATION_LOST();
        I2CDELAY();
        started = false;
}
 
/* Write a bit to I2C bus */
void i2c_write_bit(bool bit)
{
        if (bit) 
                READSDA();
        else 
                CLRSDA();
        I2CDELAY();
        /* Clock stretching */
        while (READSCL() == 0)
                ;  /* You should add timeout to this loop */
        /* SCL is high, now data is valid */
        /* If SDA is high, check that nobody else is driving SDA */
        if (bit && READSDA() == 0) 
                ARBITRATION_LOST();
        I2CDELAY();
        CLRSCL();
}
 
/* Read a bit from I2C bus */
bool i2c_read_bit(void)
{
        bool bit;
        /* Let the slave drive data */
        READSDA();
        I2CDELAY();
        /* Clock stretching */
        while (READSCL() == 0)
                ;  /* You should add timeout to this loop */
        /* SCL is high, now data is valid */
        bit = READSDA();
        I2CDELAY();
        CLRSCL();
        return bit;
}
 
/* Write a byte to I2C bus. Return 0 if ack by the slave */
bool i2c_write_byte(bool send_start, bool send_stop, unsigned char byte)
{
        unsigned bit;
        bool nack;
        if (send_start) 
                i2c_start_cond();
        for (bit = 0; bit < 8; bit++) {
                i2c_write_bit((byte & 0x80) != 0);
                byte <<= 1;
        }
        nack = i2c_read_bit();
        if (send_stop)
                i2c_stop_cond();
        return nack;
}
 
/* Read a byte from I2C bus */
unsigned char i2c_read_byte(bool nack, bool send_stop)
{
        unsigned char byte = 0;
        unsigned bit;
        for (bit = 0; bit < 8; bit++)
                byte = (byte << 1) | i2c_read_bit();             
        i2c_write_bit(nack);
        if (send_stop)
                i2c_stop_cond();
        return byte;
}

probleme d'adressage registre SFR pour microprocesseur 80c515

C

Vue hybride

Discussions similaires

Partager

Partager