PIC16f877 avec mikroC et acquisition de mesures

Version imprimable

Bonsoir ,
je programme sur mikroc pro v4.6, c'est la première fois que j'utilise ce logiciel.
je souhaiterais réaliser un système d'acquisition de température de 12 sondes et qui les affiche sur une interface graphique développée en C#.

je travaille avec PROTEUS PRO V7.7 sp2, j'ai donc utiliser un PIC 16F877 et j'ai produit le code ci-dessous, mais il n'a pas bien fonctionné avec mon interface en C# parce qu'il me transmet les 12 valeurs des sondes à l'instant où j'envoie la lettre 'c'.

ma demande et de m'aider à modifier ce programme afin d'avoir la possibilité de recevoir ces valeurs l'une après l'autre à chaque fois que j’envoie la lettre 'c' au PIC.

Merci d'avance pour vos réponses.

voici le code :

Code:

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
float rtdv, rtdr, temp, y;
int msd, isd, i;
char temperature[6];
char uart_rd;
 
calcule()                      
{
rtdv=rtdv *5/1024;
rtdv=rtdv/5;
rtdr=rtdv*1000.0/(5.0-rtdv);
y=0.15274-(rtdr-100.065)*0.0002310; 
if (y>=0)y = sqrt(y);
temp = (y-0.39083)/(-0.0001155);
bytetostr(temp,temperature);
delay_ms(1);
}
 
affichage()                                        
{
UART1_Write_Text(temperature);
strcpy(temperature,"");
UART1_Write(13);                   
}
 
 
void main()
{
 
TRISA = 0xFF;                              
TRISE = 0xFF;
TRISB = 0x00;                                
 
PORTB = 1;                            
 
 
UART1_Init(9600);
 
for(;;)                                    
{       portb.f1=1;
        if (UART1_data_ready())
         {
                  uart_rd = UART1_read();
                  if(uart_rd=='c')                 // envoie de la lettre c
                  {
                        PORTB.f0=1;                // port RB0 est à 1
                        for (i=0;i<6;i++)
                        {
                         delay_ms(5);            
                         rtdv=adc_read(i);
                         UART1_Write(13);        
                         calcule();             
                         affichage();     
                         }
 
                        PORTB.f0=~portb.f0;        // port RB0 prend le complément de l'état avant
                        for (i=0;i<6;i++)
                        {
                         delay_ms(5);
                         rtdv=adc_read(i);
                         UART1_Write(13);    
                         calcule();          
                         affichage();      
                         }
                 }
         }
}
}

09/07/2014, 09h24
schonai

Bonjour,
Je ne vois pas vraiment où est ton problème, tu as déjà fait le gros du travail.
Si tu utilise une variable que tu incrémentes à chaque réception de la lettre 'c' tu pourras sélectionner la bonne sonde.
09/07/2014, 20h08
x saber x

Bonjour schonai,
Je ne vous cache pas, vu que je suis débutant en ce sujet, je suis bloqué à ce niveau.. c'est après plusieurs recherches sur internet que j'ai pu écrire ce code, mais honnêtement j'ai pas trouvé un exemple ou une méthode qui m'aide à modifier le programme selon mon besoin.. c'est pour cet intérêt que je sollicite votre aide..

le code fonctionne actuellement comme suit :

- au début, la pine RB0 = 1, quand j'envoie la lettre 'c', le PIC m'envoie 6 valeurs successive ensuite il rend RB0 = 0 et il m'envoie de suite 6 autres valeurs dans le même ordre, dont la totalité est 12 valeurs tel que :
c
RA0
RA1
RA2
RA3
RA5
RE0
RA0
RA1
RA2
RA3
RA5
RE0

- mon besoin est que je veux, à chaque fois que j'envoie la lettre 'c', je reçois les donnée somme suit :
c
RA0
c
RA1
c
RA2
c
RA3
c
RA5
c
RE0
c
RA0
c
RA1
c
RA2
c
RA3
c
RA5
c
RE0

pouviez vous m'indiquez exactement où j’interviens sur le code pour le modifier selon mon besoin?
merci

Pour l'instant le code à pour schéma
Code:

1 2 3 4 5 6 7 8 attente événement boucle 1 affichage fin boucle 1 boucle 2 afficahge fin boucle 2
Le but est d'obtenir :
Code:

1 2 3 4 5 6 7 8 9 boucle 1 attente événement affichage fin boucle 1 boucle 2 attente événement afficahge fin boucle 2
Il y a donc une première solution très simple. Elle n'est pas élégante mais peut être un commencement.

09/07/2014, 23h00
x saber x
si j'ai bien compris, le schéma du code suivant :
Code:

1 2 3 4 5 6 7 8 9 boucle 1 attente événement affichage fin boucle 1 boucle 2 attente événement affichage fin boucle 2
donne :

c
RA0
RA1
RA2
RA3
RA5
RE0
c
RA0
RA1
RA2
RA3
RA5
RE0

si c'est le cas, alors ce n'est pas exactement le but souhaité.. parce que à chaque envoi de la lettre 'c' au PIC, on doit recevoir la valeur du pin dont l'ordre est cité ci-dessus..
sinon, pouviez vous modifier mon code afin que je puisse le tester?
merci
10/07/2014, 01h45
schonai
Citation:

Envoyé par x saber x

si j'ai bien compris, le schéma du code suivant :
donne :

c
RA0
RA1
RA2
RA3
RA5
RE0
c
RA0
RA1
RA2
RA3
RA5
RE0

Non, cette trace est obtenue par un algo de la forme :
Code:

1 2 3 4 5 6 7 8 9 attente événement boucle 1 affichage fin boucle 1 attente événement boucle 2 affichage fin boucle 2
Avec le code que je te propose tu dois attendre un caractère à chaque tour de boucle et donc entre chaque lecture.
Il ne reste plus qu'à définir la méthode pour "l'attente de l'événement" et tu l'as déjà fait au niveau global. Il ne te reste plus qu'à le faire de manière isolée. Je ne peux que te conseiller d'écrire une fonction waitC().
Une fois cette première version réalisée on pourra voir comment factoriser certaine partie du code.

Citation:

Envoyé par schonai

Non, cette trace est obtenue par un algo de la forme :

Code:

1
2
3
4
5
6
7
8
9
 
attente événement
boucle 1
    affichage
fin boucle 1
attente événement
boucle 2
    affichage
fin boucle 2

Avec le code que je te propose tu dois attendre un caractère à chaque tour de boucle et donc entre chaque lecture.
Il ne reste plus qu'à définir la méthode pour "l'attente de l'événement" et tu l'as déjà fait au niveau global. Il ne te reste plus qu'à le faire de manière isolée. Je ne peux que te conseiller d'écrire une fonction waitC().
Une fois cette première version réalisée on pourra voir comment factoriser certaine partie du code.

bonjour schonai,
j'ai me suis arrivé à écrire le code ci-dessous.. sauf qu'au lieu d'envoyer à chaque fois une lettre différente au autres, je veux envoyer toujours la même lettre et que le code doit s’exécuter dans le même ordre.
c'est vraiment mes premiers essaies en programmation, et je n'ai pas compris comment écrire une fonction waitC().
pouviez vous me donnez des exemples très proche de ce que j'ai envie de faire? ou de modifier mon programme ))..
merci

Code:

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
 
char x;
 
calcule() {....}
affichage() {....}
 
void main()
{
 
TRISA = 0xFF;
TRISE = 0xFF;
TRISB = 0x00;
 
PORTB = 1;
 
 
UART1_Init(9600);
 
while(1)
{       portb.f1=1;
        if (UART1_data_ready())
         {
          x = UART1_read();
          }
              if(x =='a')
              {
                        PORTB.f0=1;
                        delay_ms(5);
                         rtdv=adc_read(i);
                         calcule();
                         affichage();
              }
 
                else if(x =='z')
              {
                        PORTB.f0=1;
                         delay_ms(5);
                         rtdv=adc_read(i);
                         calcule();
                         affichage();
              }
 
               else if(x =='e') 
              {
                        PORTB.f0=1;
                         delay_ms(5);             
                         rtdv=adc_read(2);
                         calcule();               
                         affichage(); 
              }
               else if(x =='r')                
              {
                        PORTB.f0=1;               
                         delay_ms(5);            
                         rtdv=adc_read(3);
                         calcule();  
                         affichage();
              }
               else if(x =='t')  
              {
                        PORTB.f0=1; 
                         delay_ms(5); 
                         rtdv=adc_read(4);
                         calcule();  
                         affichage();
              }
               else if(x =='y') 
              {
                        PORTB.f0=1;
                         delay_ms(5);   
                         rtdv=adc_read(5);
                         calcule();               
                         affichage();
              }
 
              else if(x =='u')            
              {
                        PORTB.f0=0
                         delay_ms(5);
                         rtdv=adc_read(0);
                         calcule();    
                         affichage();
               }
 
               else if(x =='i')                
              {
                        PORTB.f0=0;      
                         delay_ms(5);
                         rtdv=adc_read(1);
                         calcule();               
                         affichage();
              }
              else if(x =='o')       
              {
                        PORTB.f0=0;    
                         delay_ms(5);
                         rtdv=adc_read(2);
                         calcule();          
                         affichage();
              }
               else if(x =='p') 
              {
                        PORTB.f0=0; 
                         delay_ms(5);
                         rtdv=adc_read(3);
                         calcule(); 
                         affichage(); 
              }
 
              else if(x =='q')  
              {
                        PORTB.f0=0;  
                         delay_ms(5);
                         rtdv=adc_read(4);
                         calcule();  
                         affichage();
               }
 
               else if(x =='s')
              {
                        PORTB.f0=0; 
                         delay_ms(5);
                         rtdv=adc_read(5);
                         calcule();  
                         affichage();
               }
 
              x='\0';
      }
 
}

Citation:
Envoyé par x saber x
bonjour schonai,
j'ai me suis arrivé à écrire le code ci-dessous.. sauf qu'au lieu d'envoyer à chaque fois une lettre différente au autres, je veux envoyer toujours la même lettre et que le code doit s’exécuter dans le même ordre.
Code:

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 while(1) { portb.f1=1; if (UART1_data_ready()) { x = UART1_read(); } if(x =='a') { ... } else if(x =='z') { ... } else if(x =='e') { ... } else if(x =='r') { ... } else if(x =='t') { ... } else if(x =='y') { ... } else if(x =='u') { ... } else if(x =='i') { ... } else if(x =='o') { ... } else if(x =='p') { ... } else if(x =='q') { ... } else if(x =='s') { ... } x='\0'; } }
azertyuiopqs... La question, c'est quel processus l'utilisation de différentes lettres te permet de simuler ?
L'important n'est pas vraiment que les lettres soient différentes mais ce qui est fondamental c'est quelles aient un ordre. Tu sais que tu dois envoyer un 't' parce que juste avant tu as envoyé un 'r'. Tu te souviens de ça car tu as une mémoire et que ton clavier te fournies un ordre pour les touches. Donc se qu'il te faut c'est une variable sur un ensemble ordonné. Ça tombe bien, il n'y a que ça en C X). Tu peux prendre un int par exemple (le mieux c'est un unsigned char).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 PORTB.f0=1 rtdv=adc_read(0); ... rtdv=adc_read(1); ... rtdv=adc_read(2); ... rtdv=adc_read(3); ... rtdv=adc_read(4); ... rtdv=adc_read(5); PORTB.f0=0 ...
C'est pas que la solution est dans ton(?) code mais presque... La seule subtilité est de changer la valeur du PORTB et de réinitialiser ton compteur (ta variable) au bout de 5 itérations. Tu peux le faire avec une condition ou un modulo par exemple.

Citation:

Envoyé par x saber x

je n'ai pas compris comment écrire une fonction waitC().

Le but de ton programme est de lire une tension QUAND tu reçois un caractère (c mais osef). Il y a donc deux parties :
- Attendre l’événement "je reçois un caractère".
- Lire la tension.

Pour l'instant, ton programme est dans une boucle infinie, normal on programme un microcontrôleur. Si des données sont disponibles alors tu vérifies que c'est un 'c' et alors tu fais ta seconde partie, sinon tu ne fais rien.
Avec une fonction dédiée à l'attente de ton caractère, le système est un peu différent. Tu as toujours ta boucle infinie principale mais dans une même itération, tant que tu ne reçois pas ton caractère, tu attends jusqu'à la réception d'un caractère 'c', puis tu fais ta seconde partie.

Je pense que je t'ai donné toute les clefs pour résoudre ton problème.

23/07/2014, 21h30
x saber x

schonai, merci pour votre aide!!