Bonjour Hibernatus34,
J´ai reussis a deceler les problemes qui empêchaient le transfert ligne par ligne en integralite des positions(X,Y) du fichier texte depuis le pc vers le microncontrôleur.
Voici les causes:
- la valeur de la frequence du quartz qui se trouvait sur mon circuit ne correspondait pas a celle que j´utilisais dans le programme du microncontrôleur. le quartz du circuit detenait la valait 7,372MHz et celui du programme du microcontrôleur correspondait a 8MHz. Il a fallu que je supprime la valeur 8MHz et que je travaille avec la valeur 7,372MHz.
- J´ai diminue le Baudrate du pc, du microcontrôleur et des deux moteurs de commande. J´ai choisis 9600bps comme baudrate pour les trois plateformes.
- J´ai modifie le mode de fonctionement de la fonction ISR(USART0_RX_vect), sans toutefois modifier la structure que tu m´avais proposee. Comme tu avais toi même pu le remarquer, on ne doit pas rester longtemps dans cette fonction. Ou du moins cette fonction ne doit pas effectuer plusieurs tâches. Avant ma modification, cette fonction recevait et envoyait en même les positions qu´elle devait recevoir. C´etait trop pour cette fonction. Alors j´ai declare une variable volatile au sein du programme que j´ai utilise dans cette fonction. Plus tard dans la boucle infinie "while(1)", j´utilise cette variable pour effectuer le transfert des positions vers les deux moteurs de commande.
- J´ai modifie le nombre de stopbits. J´utilise maintenant 1 stopbit.
- J´ai decouvert qu´il etait possible d´activer et de deactiver les reponses des moteurs de commande. J´ai donc deactive les reponses des deux moteurs . Je l´ai fait en me servant des instructions de la doc:
Code :
1
2
3
4
5
|
USART1_Send("#1|0\r"); // Deactivativation des reponses du moteur de commande numero 1
USART1_Send("#2|0\r"); // Deactivativation des reponses du moteur de commande numero 2
//USART1_Send("#1|1\r"); // Activativation des reponses du moteur de commande numero 1
//USART1_Send("#2|1\r"); // Activativation des reponses du moteur de commande numero 2 |
-A l´aide de l´oscilloscope, j´ai constate que le pc envoyait tous les 200ms les positions au microcontrôleur. Le microcontrôleur recevait au plus trois positions et retournait apres 3,2s un "ACK" au pc. D´apres le code c++, le pc devait attendre un "ACK" du microcontrôleur avant d´envoyer la prochaine position. Helas le pc n´attends et il se contente d´envoyer les donnees au microcontrôleur tous les 200ms. Pourtant le microcontrôleur retourne tous les
3,2s un "ACK". Bref le pc n´attendait pas assez longtemps le "ACK" du microcontrôleur avant d´envoyer la pochaine decision. Au vu de ce constat, j´ai jete un coup d´oeil aux code du pc et j´ai augmente l´attente du pc. en fait j´ai augmente le parametre " timeouts.ReadTotalTimeoutConstant " :
Code :
1
2
|
timeouts.ReadTotalTimeoutConstant = 4000; // Attendre 4s la reponse du microcontrôleur |
Apres cette modification, le transfert de toutes les positions du fichier texte depuis le pc vers le microcontrôleur s´est effectue sans probleme. En clair le pc et microcontrôleur communique bien lorsque j´effectue le deboggage.
PS: Hibernatus34, merci pour ton aide. Grâce a toi j´ai appris enormement. Tu m´as ete d´une tres grande aide. Je dirais même que sans toi j´y serais pas arrive. J´avais tellement de lacunes. Merci du fond du coeur et je te prie de continuer a aider ainsi les membres qui sont nuls comme moi. Car je l´etais et c´est fort probable que je le suis toujours. Merci.
Voici les codes.
PC:
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
|
#include <fstream>
#include <string>
#include <iostream>
#include <sstream>
#include <Windows.h>
using namespace std;
// Envoie une commande caractère par caractère, et teste la réception d'un ACK
static bool EnvoieCommande(HANDLE h, string s)
{
DWORD length;
char c;
// S'il y avait des réponses à lire depuis la dernière commande,
// trop tard, on les supprime.
PurgeComm(h, PURGE_RXCLEAR);
if (!WriteFile(h, s.c_str(), s.size(), &length, 0) || length != s.size())
{
cout << "Erreur de WriteFile" << endl;
return false;
}
if (!ReadFile(h, &c, 1, &length, 0) || length != 1)
{
cout << "Erreur de ReadFile (time-out)" << endl;
return false;
}
cout << "Réponse : " << (int)c << endl;
return c == '\x06'; // ACK
}
int main(void)
{
ifstream file("koordinaten.txt", ios::in | ios::binary);
string line;
if (!file)
{
cout << "Erreur: Impossible d´ouvrir le fichier en mode lecture" << endl;
return 1;
}
// Ouverture du port COM (c'est votre code tel quel)
HANDLE h = CreateFile("COM1", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (h == INVALID_HANDLE_VALUE)
{
cout << "Erreur: Impossible d´ouvrir le port série" << endl;
return 1;
}
DCB dcb = { 0 };
BOOL dcbOk = GetCommState(h, &dcb);
dcb.BaudRate = CBR_9600;
dcb.ByteSize = 8;
dcb.Parity = NOPARITY;
dcb.StopBits = ONESTOPBIT;
dcb.fOutxCtsFlow = false;
dcbOk = SetCommState(h, &dcb);
COMMTIMEOUTS timeouts = { 0 };
timeouts.ReadIntervalTimeout = 100;
timeouts.ReadTotalTimeoutMultiplier = 100;
timeouts.ReadTotalTimeoutConstant = 4000; // Attendre 4s la reponse du microcontrôleur
timeouts.WriteTotalTimeoutMultiplier = 100;
timeouts.WriteTotalTimeoutConstant = 100;
if (!SetCommTimeouts(h, &timeouts))
{
cout << "Erreur: SetCommTimeouts" << endl;
CloseHandle(h);
return 1;
}
DWORD dwModemStatus;
BOOL fCTS; // fDSR, fRING, fRLSD;
if (!GetCommModemStatus(h, &dwModemStatus))
{
cout << "Error in GetCommModemStatus" << endl;
CloseHandle(h);
return 1;
}
fCTS = MS_CTS_ON & dwModemStatus;
// Lecture ligne par ligne
while (getline(file, line))
{
int x; // x, y du texte
int y;
int x_steps; // x, y en pas moteur
int y_steps;
stringstream input; // flux d'entrée (une ligne du texte)
stringstream output; // flux de sortie (une paire de coordonnées)
// Une ligne devient un flux d'entrée
input.str(line);
// Extraction du X et du Y.
if (input.get() != 'X')
continue;
input >> x;
if (input.get() != 'Y')
continue;
input >> y;
// Conversion de la position en pas moteur
// J'ai rendu le calcul compatible avec le type int. (et je le trouve plus lisible)
x_steps = x * 127 / 500;
y_steps = y * 127 / 500;
// Envoi des coordonnées par le port série
output << 'D';
output << x_steps;
output << ',';
output << y_steps;
output << 'F';
cout << "Envoi de : " << output.str() << endl;
if (EnvoieCommande(h, output.str()))
cout << "OK" << endl;
else
cout << "ERREUR" << endl;
}
CloseHandle(h);
return 0;
} |
Microcontrôleur
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
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
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
|
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <avr/pgmspace.h>
#define F_CPU 3686400UL
#include <util/delay.h>
#define FOSC 7372000 // Clock Speed
#define BAUD 9600UL
// calcul du Baudrate:
#define UBRR_VAL ((FOSC+BAUD*8)/(BAUD*16)-1) // clever runden
#define usart_buffer_max_size 512u
#define usart_command_max_size 20
char usart_command[usart_command_max_size + 1] = {0};
char usart0_tx_buffer[usart_buffer_max_size ];
char usart1_tx_buffer[usart_buffer_max_size ];
volatile uint8_t usart_command_size = 0;
volatile uint8_t usart0_tx_buffer_size = 0;
volatile uint8_t usart0_tx_buffer_start = 0;
volatile uint8_t usart1_tx_buffer_size = 0;
volatile uint8_t usart1_tx_buffer_start = 0;
volatile uint8_t command_ready = 0;
// Configuration USART0 and USART1
// Set baud rate
void USART_Init (unsigned int ubrr)
{
UBRR0H = (unsigned char)(ubrr>>8);
UBRR0L = (unsigned char) ubrr;
UBRR1H = (unsigned char)(ubrr>>8);
UBRR1L = (unsigned char) ubrr;
// Enable receiver and transmitter and set frame format: 8data, 2stop bit
UCSR0B = (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0)|(0<<TXCIE0)|(0<<UCSZ02)|(0<<UDRIE0);
UCSR0C = (0<<USBS0) | (1<<UCSZ01)|(1<<UCSZ00); // 1 Stopbit, data=8 Bit
UCSR1B = (1<<RXEN1)|(1<<TXEN1)|(0<<RXCIE1)|(0<<TXCIE1)|(0<<UCSZ12)|(0<<UDRIE1);
UCSR1C = (0<<USBS1) |(1<<UCSZ11)|(1<<UCSZ10); // 1 Stopbit, data=8 Bit
}
// Ajout dans une file
void USART0_QueueIn(char c)
{
int i;
if (usart0_tx_buffer_size < usart_buffer_max_size)
{
i = (usart0_tx_buffer_size + usart0_tx_buffer_start) % usart_buffer_max_size;
usart0_tx_buffer[i] = c;
++usart0_tx_buffer_size;
}
else
{
usart0_tx_buffer_size = 0;
}
}
// Sortie d'une file
// J'utilise le caractère nul pour dire qu'il ne reste rien dans la file
// Ca signifie que la file n'est pas prête à recevoir du binaire
char USART0_QueueOut(void)
{
char c;
if (usart0_tx_buffer_size == 0)
return 0;
c = usart0_tx_buffer[usart0_tx_buffer_start];
--usart0_tx_buffer_size;
usart0_tx_buffer_start = (usart0_tx_buffer_start + 1) % usart_buffer_max_size;
return c;
}
// Ajout dans une file
void USART1_QueueIn(char c)
{
int i;
if (usart1_tx_buffer_size < usart_buffer_max_size)
{
i = (usart1_tx_buffer_size + usart1_tx_buffer_start) % usart_buffer_max_size;
usart1_tx_buffer[i] = c;
++usart1_tx_buffer_size;
}
else
{
usart1_tx_buffer_size = 0;
}
}
// Sortie d'une file
// J'utilise le caractère nul pour dire qu'il ne reste rien dans la file
// Ca signifie que la file n'est pas prête à recevoir du binaire
char USART1_QueueOut(void)
{
char c;
if (usart1_tx_buffer_size == 0)
return 0;
c = usart1_tx_buffer[usart1_tx_buffer_start];
--usart1_tx_buffer_size;
usart1_tx_buffer_start = (usart1_tx_buffer_start + 1) % usart_buffer_max_size;
return c;
}
// Envoie une réponse sur l'USART0 via la file de transfert
static void USART0_Send(const char *s)
{
int i;
for (i = 0; s[i] != 0; ++i)
USART0_QueueIn(s[i]);
if (usart0_tx_buffer_size > 0)
UCSR0B |= (1 << UDRIE0);
}
// Envoie une commande sur l'USART1 via la file de transfert
static void USART1_Send(const char *s)
{
int i;
for (i = 0; s[i] != 0; ++i)
USART1_QueueIn(s[i]);
if (usart1_tx_buffer_size > 0)
UCSR1B |= (1 << UDRIE1);
}
// Traitement de la commande
static void ProcessCommand(void)
{
int i;
int x;
int y;
char x_moteur[12];
char y_moteur[12];
// On extrait le X et le Y, puis on génère les commandes moteurs
for (i = 0; i < usart_command_size; ++i)
if (usart_command[i] == ',')
break;
if (i <= 0 || i >= usart_command_size - 1)
{
// On n'a pas trouvé la virgule au milieu de la chaîne -> erreur
USART0_Send("\x15"); // NAK , L´envoi est un echec
usart_command_size = 0;
return;
}
// Je transforme volontairement x et y en int pour te permettre des contrôles ou des calculs
usart_command[i] = 0;
usart_command[usart_command_size] = 0;
x = atoi(usart_command);
y = atoi(usart_command + i + 1);
usart_command_size = 0;
// Envoi des commandes des moteurs
itoa(x, x_moteur, 10);
itoa(y, y_moteur, 10);
USART1_Send("#1s");// Envoi position x_moteur
USART1_Send(x_moteur);
USART1_Send("\r");
USART1_Send("#1A\r");// Activation du deplacement de la platine sur l´axe x
USART1_Send("#2s"); // Envoi position y_moteur
USART1_Send(y_moteur);
USART1_Send("\r");
USART1_Send("#2A\r"); // Activation du deplacement de la platine sur l´axe y
_delay_ms(30000); // Attendre 30000ms --> 3s
// ACK --->l´envoi est un sucess (Reponse au pc),
// on peut envoyer les prochaines positions
USART0_Send("\x06"); // ACK
}
// La fonction d´interruption de reception du byte
// Cette fonction est active lorsque RXCIE0 = 1
ISR(USART0_RX_vect)
{
char data;
data = UDR0;
if (data == 'F')
{
// Traitement de la commande ("/n X,Y /r")
command_ready = 1;
}
else if (data == 'D')
{
// Démarrage d'une nouvelle commande
usart_command_size = 0;
}
else
{
// Quand on ne reçoit ni F ni D, on enregistre le caractère dans la commande
if (usart_command_size < usart_command_max_size)
{
usart_command[usart_command_size] = data;
++usart_command_size;
}
else
{
usart_command_size = 0;
}
}
}
// La fonction d´interruption d´envoi de byte
// Cette fonction est active lorsque UDRIE0 = 1
ISR(USART0_UDRE_vect)
{
UDR0 = USART0_QueueOut();
// S'il n'y a plus de données à envoyer on arrete l'emission
if (usart0_tx_buffer_size == 0)
UCSR0B &= ~(1 << UDRIE0);
}
// La fonction d´interruption d´envoi de byte
// Cette fonction est active lorsque UDRIE1 = 1
ISR(USART1_UDRE_vect)
{
UDR1 = USART1_QueueOut();
// S'il n'y a plus de données à envoyer on arrete l'emission
if (usart1_tx_buffer_size == 0)
UCSR1B &= ~(1 << UDRIE1);
}
void ParametrageMoteur(void)
{
USART1_Send("#1|0\r"); // Deactivativation des reponses du moteur de commande numero 1
USART1_Send("#2|0\r"); // Deactivativation des reponses du moteur de commande numero 2
//USART1_Send("#1|1\r"); // Activativation des reponses du moteur de commande numero 1
//USART1_Send("#2|1\r"); // Activativation des reponses du moteur de commande numero 2
USART1_Send("#1D0\r"); // Considerer la position actuelle comme origine du repere sur l´axe y
USART1_Send("#2D0\r"); // Considerer la position actuelle comme origine du repere sur l´axe x
USART1_Send("#1p2\r"); // Mode de travail moteur nr 3
USART1_Send("#2p2\r"); // Mode travail moteur nr 2
}
int main (void)
{
USART_Init(UBRR_VAL); // Initialisation de l´USART0 et l´USART1
RS485_Init(); // Contrôl de l´envoi des positions via l´USART1
// TODO: Ici il faut paramétrer les moteurs (mode de positionnement etc.)
ParametrageMoteur(); // Mode de Positionnement et de travail
sei(); // Activation des fonctions d´interruption
while (1) // Endlosschleife
{
if (command_ready)
{
ProcessCommand();
command_ready = 0;
}
}
} |
10/10/2012, 14h29
arthur 
00
