Discussion :

[sone47]

oui tout a fait, via deux fonctions deja implementées transmit et receive.
merci

[Emmanuel Delahaye]

oui tout a fait, via deux fonctions deja implementées transmit et receive.
merci

OK. Si j'ai bien compris, chaque fonction ne gère qu'un seul caractère.

Quel est le format des messages échangés ? (texte, binaire...)

[sone47]

Les fonctions peuvent gerer plusieurs caracteres il y a un parametre qui permet de specifier le nombre, mais je ne l'utilise qu'avec un (pour l'instant).
Voici le code que j'ai réaliser pour l'instant:
-- les choix de menu sont envoyées et a la board et traités par le soft pc.
-- on peut setter dans le soft pc une variable "non_saisie" qui, tant qu'elle sera settée, fera que le soft pc ne traitera pas ces datas (datas uniquement envoyées sur la board).

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
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
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
 
/********************************************/
/****** include and define ************************/
/********************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <pthread.h>
#include <windows.h>
 
/********************************************/
/****** global constant **************************/
/********************************************/
char c_t,ct;
char bufferChar[100];
char * readPtr, * writPtr;
int non_saisie=0;
 
/*********************************************/
/****** functions *******************************/
/*********************************************/
 
int    main(int argc, char *argv[]);
 
int transmit(char *pdata, int size);
int receive(char *pdata, int size);
 
void menu_pcbis(void);
void Configuration_pc(void);
 
/*********************************************/
/****** thread task ******************************/
/*********************************************/
static void *thread_transmit (void *p_data)
{
	int ret_t=0;
	while(1)
	{
		ret_t=kbhit();
		if (ret_t!=0)
		{
			c_t = getch();
			printf("**********************************\n");
			printf("touche transmise %c\n",c_t);//c'est ici que j'insererai le transmit 
			printf("**********************************\n");
			if(non_saisie!=1)
			{
				*writPtr++=c_t;
			}
		}
	}
	(void) p_data;
	return NULL;
}
 
static void *thread_receive (void *p_data)
{
	int ret_r=1;
	char c_r;
	while(1)
	{
		ret_r = kbhit();
		if (ret_r!=0)
		{
 
		}
	}
	(void) p_data;
	return NULL;
}
 
 
/****************************************/
/****************** main ******************/
/****************************************/
int    main(int argc, char *argv[])
{
/*****************************************/
/****** thread declaration *********************/
/*****************************************/
	pthread_t ta;
	pthread_t tb;
/*****************************************/
/****** main routine *************************/
/*****************************************/
	{
		short ret = 0;
		int ret_thread =1;
		int exit=0;
		int affiche=1;
 
		readPtr=bufferChar;
		writPtr=bufferChar;
 
/****** thread creating ***********************/
/*****************************************/
		ret_thread = pthread_create (&ta, NULL, thread_transmit, NULL);
		if(ret_thread!=0){		
			printf("\nerror thread transmit\n");
			return(0);
		}
		else{
			printf("transmit thread created\n");
			ret_thread = pthread_create (&tb, NULL, thread_receive, NULL);
			if(ret_thread!=0)
			{
				printf("\nerror thread receive\n");
				return (0);
			}
			else
			{
				printf("receive thread created\n");
			}
		}
/*****************************************/
		while(1)
		{
			if(affiche==1)
			{
				printf ("\n**********************************\n");
				printf ("**********************************  \n");
				printf ("*          MAIN MENU                \n");
				printf ("* [0] Configuration                 \n");
				printf ("* [1] Player menu                   \n");
				printf ("* [x] exit                          \n");
				printf ("**********************************  \n");
				printf ("--------->\n\b");
				affiche=0;
			}
			if(readPtr!=writPtr)
			{
				while(readPtr!=writPtr)
				{
					ct=*readPtr++;
				}
				switch(ct)
				{
					case '0' :Configuration_pc();							
						      affiche=1;
							  break;
					case '1' :menu_pcbis();		
						      affiche=1;
							  break;
					case 'x' :exit=1;						
							  break;
					default  :printf ("wrong input main menu\n");
							  break;
				}
			}
			if(exit==1)
			{
				break;
			}
			//payload = io_base ;
		}
	}
	pthread_cancel (ta);
	pthread_cancel (tb);
	return (0);
}
/*****************************************/
/*****************************************/
void Configuration_pc(void)
{
	int i=0;
    int back=0;
	int affiche=1;
	while(1)
	{
		if(affiche==1)
		{
			printf ("**********************************\n");          //max number of digits for display
			printf ("*    *  CONFIGURATION             \n");
			printf ("*    *----------------------------\n");
			printf ("*    * (0) Audio Gains            \n");
			printf ("*    * (1) Reset Gains            \n");
			printf ("*    *----------------------------\n");
			printf ("*    * (x) back                   \n");
			printf ("**********************************\n");
			affiche=0;
		}
		if(readPtr!=writPtr)
		{
			while(readPtr!=writPtr)
			{
				ct=*readPtr;
				readPtr++;
			}
			printf ("**********************************\n");
			switch(ct)
			{
				case '0' :
					printf ("*    *    ************************\n");          
					printf ("*    *    * Audio Gains       \n");
					printf ("*    *    ************************\n");
					affiche=1;
					break; 
				case '1' :
					printf ("*    *    ************************\n");
					printf ("*    *    *  reset\n");
					printf ("*    *    ************************\n");
					affiche=1;
					break;
				case 'x':
					printf ("*    *    * back\n");
					back=1;
					break;
				default  :
					printf ("*    *    * wrong input\n");
					affiche=1;
					break;
			}
			printf ("**********************************\n");
		}
		if(back==1)
		{
			break;
		}
	}
}
/*****************************************/
/*****************************************/
void menu_pcbis()
{
	int i=0;
    int back=0;
	int affiche=1;
	while(1)
	{
		if(affiche==1)
		{
			printf ("**********************************\n");
			printf ("            Menu      \n");
			printf ("----------------------------------\n");
			printf ("--- Select Sampling rate ---------\n");
			printf (" (0):	32 kHz\n");
			printf (" (1):	44.1 kHz\n");
			printf (" (2):	48 kHz\n");
			printf ("--- Select mode ------------------- \n");
			printf (" (m):	Mono\n");
			printf (" (s):	Stereo\n");
			printf ("-----------------------------------\n");
			printf (" (r) Start record \n");
			printf (" (p) Start play   \n");
			printf (" (x) back         \n");
			printf ("**********************************\n");
			affiche=0;
		}
		if(readPtr!=writPtr)
		{
			while(readPtr!=writPtr)
			{
				ct=*readPtr;
				readPtr++;
			}
			printf ("**********************************\n");
			switch(ct)
			{
				case '0' :
					printf("*    *    * 32 kHz\n");
					affiche=1;
					break;
				case '1' :
					printf("*    *    * 44.1 kHz\n");
					affiche=1;
					break;
				case '2' :
					printf("*    *    * 48 kHz\n");
					affiche=1;
					break;
				case 'm' :
					printf("*    *    * mono mode\n");
					affiche=1;
					break;
				case 's' :
					printf("*    *    * stereo mode\n");
					affiche=1;
					break;
				case 'r' :
					printf("*    *    * Start record\n");
					non_saisie=1;
					for(i=0;i<15;i++)
					{
						printf("recording .  \b\b\b\b\b\b\b\b\b\b\b\b\b");
						Sleep(333);
						printf("recording .. \b\b\b\b\b\b\b\b\b\b\b\b\b");
						Sleep(333);
						printf("recording ...\b\b\b\b\b\b\b\b\b\b\b\b\b");
						Sleep(333);
					}
					non_saisie=0;
					affiche=1;
					break;
				case 'p' :
					printf("*    *    * Start play recorded\n");
					non_saisie=1;
					for(i=0;i<15;i++)
					{
						printf("playing .  \b\b\b\b\b\b\b\b\b\b\b");
						Sleep(333);
						printf("playing .. \b\b\b\b\b\b\b\b\b\b\b");
						Sleep(333);
						printf("playing ...\b\b\b\b\b\b\b\b\b\b\b");
						Sleep(333);
					}
					non_saisie=0;
					affiche=1;
					break;
				case 'x' :
					printf("*    *    * back\n");
					back=1;
					break;
				default:
					printf("*    *    * wrong input\n");
					affiche=1;
					break;
			}
			printf ("**********************************\n");
		}
		if(back==1)
		{
			break;
		}
	}
}

En l'executant on peut voir qu'en faisant le play ou le record, on peut continuer d'envoyer des datas sur la board.
J'ai cru comprendre que les variables globales n'étaient pas conseillées, pourtant je n'ai reussi pour l'instant qu'a passer par un buffer tampon global pour partager les datas.
Les commentaires sont les bienvenus étant donné que les threads sont nouveaux pour moi il doit y avoir pas mal de choses a revoir, notemment l'utilisation de la ressource car 100% des ressources cpu sont utilisées.
Merci beaucoup

[Emmanuel Delahaye]

Les fonctions peuvent gerer plusieurs caracteres il y a un parametre qui permet de specifier le nombre, mais je ne l'utilise qu'avec un (pour l'instant).

OK. C'est nouveau, parce que dans le code que tu avais montré au début, il n'y avait pas de paramètre 'longueur'.

Voici le code que j'ai réaliser pour l'instant:
-- les choix de menu sont envoyées et a la board et traités par le soft pc.
-- on peut setter dans le soft pc une variable "non_saisie" qui, tant qu'elle sera settée, fera que le soft pc ne traitera pas ces datas (datas uniquement envoyées sur la board).

Je te pose une question concernant la spécification d'interface entre tes 2 applications et tu me réponds par du code ?

C'est un peu étrange, non ? Tu ne connais pas les étapes de développement d'un projet ? Tu fonces sur le code sans savoir ce qu'il y a à coder ?

En l'executant on peut voir qu'en faisant le play ou le record, on peut continuer d'envoyer des datas sur la board.
J'ai cru comprendre que les variables globales n'étaient pas conseillées, pourtant je n'ai reussi pour l'instant qu'a passer par un buffer tampon global pour partager les datas.
Les commentaires sont les bienvenus étant donné que les threads sont nouveaux pour moi il doit y avoir pas mal de choses a revoir, notemment l'utilisation de la ressource car 100% des ressources cpu sont utilisées.

Tu fais 2 threads contenant des 'boucles blanches' (pas de fonction bloquantes, pas de suspension) et tu as l'air étonné que le CPU soit consommé à 100 % ? Ca parait un peu logique pourtant, non ?

Il y a clairement un problème de conception. Soit un utilise un seul thread avec une seule boucle et une protection de la lecture clavier par kbhit(), soit on utilise des threads bouclés avec des fonctions bloquantes comme getch().

Je ne suis pas étonné, car visiblement, tu préfères coder directement n'importe quoi sans prendre le tenps de définir ce que tu veux faire, ni comment tu veux le faire. La programmation, c'est pas du bricolage. Il y a des règles de bon usage et il faut les suivre.

http://emmanuel-delahaye.developpez.com/dev_proj.htm

J'attends toujours une spécification claire de ton problème.

Quelques remarques concernant le codage :

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
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
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
 
/* -ed- commentaires lourdingues... nettoyage */
/* ***** include and define *********************** */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <pthread.h>
#include <windows.h>
 
/* ***** global constant ************************* */
char c_t, ct;
char bufferChar[100];
char *readPtr, *writPtr;
int non_saisie = 0;
 
/* ***** functions ****************************** */
 
/* -ed- inutile. Tu n'es pas censé appeler main().
int main (int argc, char *argv[]);
*/
 
/* -ed- devrait appartenir a un header, genre "com.h"
 
int transmit (char *pdata, int size);
int receive (char *pdata, int size);
*/
 
/* -ed- inutile si le code est bien organise. (reorganisation faite)
void menu_pcbis (void);
void Configuration_pc (void);
*/
 
/* ***** thread task ***************************** */
static void *thread_transmit (void *p_data)
{
   int ret_t = 0;
   while (1)
   {
      ret_t = kbhit ();
      if (ret_t != 0)
      {
         c_t = getch ();
         printf ("**********************************\n");
         printf ("touche transmise %c\n", c_t); 
         /* c'est ici que j'insererai le transmit */
         printf ("**********************************\n");
         if (non_saisie != 1)
         {
            *writPtr++ = c_t;
         }
      }
   }
   /* -ed- c'est à cause des globales... */
   (void) p_data;
   return NULL;
}
 
static void *thread_receive (void *p_data)
{
   int ret_r = 1;
   /* -ed- variable non utilisee
   char c_r;
   */
   while (1)
   {
      ret_r = kbhit ();
      if (ret_r != 0)
      {
 
      }
   }
   (void) p_data;
   return NULL;
}
 
/* -ed- focntion non exportee, alors static : */
static void Configuration_pc (void)
{
   /* -ed- variable non utilisee
   int i = 0;
   */
   int back = 0;
   int affiche = 1;
   while (1)
   {
      if (affiche == 1)
      {
         printf ("**********************************\n"); /* max number of digits for display */
         printf ("*    *  CONFIGURATION             \n");
         printf ("*    *----------------------------\n");
         printf ("*    * (0) Audio Gains            \n");
         printf ("*    * (1) Reset Gains            \n");
         printf ("*    *----------------------------\n");
         printf ("*    * (x) back                   \n");
         printf ("**********************************\n");
         affiche = 0;
      }
      if (readPtr != writPtr)
      {
         while (readPtr != writPtr)
         {
            ct = *readPtr;
            readPtr++;
         }
         printf ("**********************************\n");
         switch (ct)
         {
         case '0':
            printf ("*    *    ************************\n");
            printf ("*    *    * Audio Gains       \n");
            printf ("*    *    ************************\n");
            affiche = 1;
            break;
         case '1':
            printf ("*    *    ************************\n");
            printf ("*    *    *  reset\n");
            printf ("*    *    ************************\n");
            affiche = 1;
            break;
         case 'x':
            printf ("*    *    * back\n");
            back = 1;
            break;
         default:
            printf ("*    *    * wrong input\n");
            affiche = 1;
            break;
         }
         printf ("**********************************\n");
      }
      if (back == 1)
      {
         break;
      }
   }
}
 
/* -ed- pas de parametres, alors 'void' */
static void menu_pcbis (void)
{
   int i = 0;
   int back = 0;
   int affiche = 1;
   while (1)
   {
      if (affiche == 1)
      {
         printf ("**********************************\n");
         printf ("            Menu      \n");
         printf ("----------------------------------\n");
         printf ("--- Select Sampling rate ---------\n");
         printf (" (0):	32 kHz\n");
         printf (" (1):	44.1 kHz\n");
         printf (" (2):	48 kHz\n");
         printf ("--- Select mode ------------------- \n");
         printf (" (m):	Mono\n");
         printf (" (s):	Stereo\n");
         printf ("-----------------------------------\n");
         printf (" (r) Start record \n");
         printf (" (p) Start play   \n");
         printf (" (x) back         \n");
         printf ("**********************************\n");
         affiche = 0;
      }
      if (readPtr != writPtr)
      {
         while (readPtr != writPtr)
         {
            ct = *readPtr;
            readPtr++;
         }
         printf ("**********************************\n");
         switch (ct)
         {
         case '0':
            printf ("*    *    * 32 kHz\n");
            affiche = 1;
            break;
         case '1':
            printf ("*    *    * 44.1 kHz\n");
            affiche = 1;
            break;
         case '2':
            printf ("*    *    * 48 kHz\n");
            affiche = 1;
            break;
         case 'm':
            printf ("*    *    * mono mode\n");
            affiche = 1;
            break;
         case 's':
            printf ("*    *    * stereo mode\n");
            affiche = 1;
            break;
         case 'r':
            printf ("*    *    * Start record\n");
            non_saisie = 1;
            for (i = 0; i < 15; i++)
            {
               printf ("recording .  \b\b\b\b\b\b\b\b\b\b\b\b\b");
               Sleep (333);
               printf ("recording .. \b\b\b\b\b\b\b\b\b\b\b\b\b");
               Sleep (333);
               printf ("recording ...\b\b\b\b\b\b\b\b\b\b\b\b\b");
               Sleep (333);
            }
            non_saisie = 0;
            affiche = 1;
            break;
         case 'p':
            printf ("*    *    * Start play recorded\n");
            non_saisie = 1;
            for (i = 0; i < 15; i++)
            {
               printf ("playing .  \b\b\b\b\b\b\b\b\b\b\b");
               Sleep (333);
               printf ("playing .. \b\b\b\b\b\b\b\b\b\b\b");
               Sleep (333);
               printf ("playing ...\b\b\b\b\b\b\b\b\b\b\b");
               Sleep (333);
            }
            non_saisie = 0;
            affiche = 1;
            break;
         case 'x':
            printf ("*    *    * back\n");
            back = 1;
            break;
         default:
            printf ("*    *    * wrong input\n");
            affiche = 1;
            break;
         }
         printf ("**********************************\n");
      }
      if (back == 1)
      {
         break;
      }
   }
}
 
/* ***************** main ***************** */
/* -ed- les parametres ne sont pas utilises ici... */
int main (void)
{
/* ***** thread declaration ******************** */
   pthread_t ta;
   pthread_t tb;
 
/* ***** main routine ************************ */
   {
   /* -ed- variable non utilisee
      short ret = 0;
   */
      int ret_thread = 1;
      int exit = 0;
      int affiche = 1;
 
      readPtr = bufferChar;
      writPtr = bufferChar;
 
/* ***** thread creating ********************** */
      ret_thread = pthread_create (&ta, NULL, thread_transmit, NULL);
      if (ret_thread != 0)
      {
         printf ("\nerror thread transmit\n");
         return (0);
      }
      else
      {
         printf ("transmit thread created\n");
         ret_thread = pthread_create (&tb, NULL, thread_receive, NULL);
         if (ret_thread != 0)
         {
            printf ("\nerror thread receive\n");
            return (0);
         }
         else
         {
            printf ("receive thread created\n");
         }
      }
/* *************************************** */
 
      while (1)
      {
         if (affiche == 1)
         {
            printf ("\n**********************************\n");
            printf ("**********************************  \n");
            printf ("*          MAIN MENU                \n");
            printf ("* [0] Configuration                 \n");
            printf ("* [1] Player menu                   \n");
            printf ("* [x] exit                          \n");
            printf ("**********************************  \n");
            printf ("--------->\n\b");
            affiche = 0;
         }
         if (readPtr != writPtr)
         {
            while (readPtr != writPtr)
            {
               ct = *readPtr++;
            }
            switch (ct)
            {
            case '0':
               Configuration_pc ();
               affiche = 1;
               break;
            case '1':
               menu_pcbis ();
               affiche = 1;
               break;
            case 'x':
               exit = 1;
               break;
            default:
               printf ("wrong input main menu\n");
               break;
            }
         }
         if (exit == 1)
         {
            break;
         }
         /* payload = io_base ; */
      }
   }
   pthread_cancel (ta);
   pthread_cancel (tb);
 
   return 0;
}

[sone47]

Bonjour,
oui par manque d'infos j'ai commencé a coder certes, mais cela n'est pas inutile, cela m'a permis de regarder les threads. Apres sur le 'projet' c'est sur j'aurais du partir toutes les cartes en mains...
Voici donc pour repartir a plat les bases du probleme:
au debut: une carte contenant un mcu et un dsp, un menu était codé sur le mcu qui permettait d'envoyer des commandes.
Premier probleme: le fait d'attendre une saisie dans le menu (expliqué au debut du post)
Deuxieme probleme: le fait de ne pas pouvoir traiter des fichiers (types mp3 ou autres).
Ces problemes nous ont amené a un projet de deporter ce menu sur le pc et via une liaison serie piloter le mcu, envoyer datas de fichier etc.
Les fonctions de transmission de données et reception sont deja implementées.
Au debut je pensais a un menu parallele sur le pc, mais il faut que le menu sur le mcu soit exactement calé celui du pc (a un transmit() sur le pc il faut un receive() sur le mcu et vice versa).
Est il preferable de laisser deux menus en paralleles ou bien de tout deporter sur le pc.
Voici donc les infos du probleme et merci encore.

[Emmanuel Delahaye]

Bonjour,
oui par manque d'infos j'ai commencé a coder certes, mais cela n'est pas inutile, cela m'a permis de regarder les threads. Apres sur le 'projet' c'est sur j'aurais du partir toutes les cartes en mains...
Voici donc pour repartir a plat les bases du probleme:
au debut: une carte contenant un mcu et un dsp, un menu était codé sur le mcu qui permettait d'envoyer des commandes.
Premier probleme: le fait d'attendre une saisie dans le menu (expliqué au debut du post)
Deuxieme probleme: le fait de ne pas pouvoir traiter des fichiers (types mp3 ou autres).
Ces problemes nous ont amené a un projet de deporter ce menu sur le pc et via une liaison serie piloter le mcu, envoyer datas de fichier etc.
Les fonctions de transmission de données et reception sont deja implementées.
Au debut je pensais a un menu parallele sur le pc, mais il faut que le menu sur le mcu soit exactement calé celui du pc (a un transmit() sur le pc il faut un receive() sur le mcu et vice versa).
Est il preferable de laisser deux menus en paralleles ou bien de tout deporter sur le pc.
Voici donc les infos du probleme et merci encore.

C'est complètement absurde d'avoir 2 menus synchronisés... Pour 'déporter un menu', on se contente de déporter la saisie et l'affichage. C'est ce qu'on fait avec n'importe quelle console distante par liaison série (RS-232, TCP/IP etc.).

Ou alors, on a un menu sur PC qui envoie des commandes à un interpréteur de commandes.

En résumé, il y a 2 architectures possibles :

Code :

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

1
2
3
4
5
 
   PC                   Carte
+--------+            +-------+
|Terminal| <========> | Menu  |
+--------+            +-------+

Code :

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

1
2
3
4
5
6
 
   PC                   Carte
+--------+            +-------------+
|  Menu  | <========> |interpreteur |
|        |            |de commandes |
+--------+            +-------------+

Il faut déjà faire ce choix. Si il faut faire en plus du ransfert de données, la 2ème solution est sans doute plus souple.

[sone47]

merci.
Le choix de la deuxieme solution [menu sur pc//interpreteur de commande sur carte] me semble aussi plus interessant, la carte embarquerait par exemple une fonction qui permetrait d'effectuer les commandes avec les parametres envoyés du pc et donc une serie de config (define etc..) lui permettant de bien interpreter les parametres.
Le pc devrait gérer l'envoi de commandes + parametres et egalement l'envoi de datas de fichier.

[Emmanuel Delahaye]

Le choix de la deuxieme solution [menu sur pc//interpreteur de commande sur carte] me semble aussi plus interessant, la carte embarquerait par exemple une fonction qui permetrait d'effectuer les commandes avec les parametres envoyés du pc et donc une serie de config

OK

(define etc..)

Cesse de raisonner en codage alors que tu es en phase de conception globale... Chaque chose en son temps...

lui permettant de bien interpreter les parametres.
Le pc devrait gérer l'envoi de commandes + parametres et egalement l'envoi de datas de fichier.

Si l'architecture menu/interpréteur de commandes est retenue, il faut maintenant parler des fonctions de la carte, et voir avec quelles commandes on va pouvoir les mettre en œuvre.

Au fait. Le menu n'est pas nécessaire. Dans un premier temps, on peut faire ceci pour tester les commandes et les réponses :

Code :

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

1
2
3
4
5
6
 
   PC                   Carte
+--------+            +-------------+
|Terminal| <========> |interpreteur |
|        |            |de commandes |
+--------+            +-------------+

Une fois que c'est au point, on peut choisir d'implémenter un menu (texte, GUI, peu importe) pour gérer les commandes et les réponses...

[sone47]

Bonjour,
Pour ne pas réinvinter la roue sur la communuication, il y a deja les fonctions permettant ces echanges de données:
transmission et reception avec comme parametre le port, l'adresse et la taille de ce que l'on envoie.
Ce que je n'arrive pas a comprendre c'est comment rendre les echanges 'aleatoire' (dans le temps), car dans tous les cas il faut bien lorsqu'il y a transmission prevoir une reception donc prevoir au prealable non?
Ensuite pour interpreter les commandes, il y avait sur la carte une lib avec les fonctions implementées. La majorité des fonctions s'appellent entre elles et permettent de configurer tous les parametres de config, puis au final appellent une fonction command qui s'occupe d'aller donner l'ordre au dsp avec les bons parametres.
D'autres fonctions sont aussi en 'lien' direct avec le dsp (boot etc).
Lorsque vous parlez d'interpreteur de commandes cela correspond il a la fonction command?
Est ce que les fonctions en 'lien direct' doivent rester sur la board et ainsi deporter uniquement sur le pc les fonctions pour la config?
(ou est ce hors conception?)
Merci encore

[Emmanuel Delahaye]

Pour ne pas réinvinter la roue sur la communuication, il y a deja les fonctions permettant ces echanges de données:
transmission et reception avec comme parametre le port, l'adresse et la taille de ce que l'on envoie.

OK, Là, tu parles implémentation (conception détailée). On en est pas encore là, car on ne sait toujours pas ce qu'il y a à transmettre... Pour le moment ces détails ne nous intéressent pas.

Je rappelle les principes de bonne gestion d'un projet quelqu'il soit :

• La conception se fait de hat en bas (le haut étant la définition du projet)
• La réalisation se fait de bas en haut (le haut étant le produit final).

Ce que je n'arrive pas a comprendre c'est comment rendre les echanges 'aleatoire' (dans le temps), car dans tous les cas il faut bien lorsqu'il y a transmission prevoir une reception donc prevoir au prealable non?

La conception montrera qu'il faut prévoir une tâche de réception qui ne fait que ça, mais on en est pas encore là. Il faut traiter les problèmes dans l'ordre...

Ensuite pour interpreter les commandes, il y avait sur la carte une lib avec les fonctions implementées. La majorité des fonctions s'appellent entre elles et permettent de configurer tous les parametres de config, puis au final appellent une fonction command qui s'occupe d'aller donner l'ordre au dsp avec les bons parametres.
D'autres fonctions sont aussi en 'lien' direct avec le dsp (boot etc).
Lorsque vous parlez d'interpreteur de commandes cela correspond il a la fonction command?

Je ne sais pas pourquoi tu te noies dans les détails d'implémentation (conception détaillée) alors qu'on ne sait toujours pas quelles sont les commandes à implémenter. On est est toujours à la phase de définition et ça n'avance pas beaucoup...

Est ce que les fonctions en 'lien direct' doivent rester sur la board et ainsi deporter uniquement sur le pc les fonctions pour la config?
(ou est ce hors conception?)

Une fois de plus tant qu'on a pas une liste claire des commandes et des réponses, on ne peut pas avancer.

Je le redemande une fois de plus :

• Quelles sont les fonctions que la carte doit réaliser ?
• Quelles sont les fonctions qui doivent être contrôlées par l'utilisateur ?
• Quels sont les paramètres de ces fonctions ?

Une fois que ce document sera rempli, on pourra élaborer un protocole applicatif (liste des commandes avec paramètres si nécessaire et réponses attendues. Traitements en cas d'erreurs etc.), qui constituera l'interpréteur de commandes.

Je rappelle le déroulement de la réalisation d'un projet :

1 - On défini ce que l'on attend du produit (Définition, spécification, cahier des charges)
2 - On trouve les moyens de le réaliser (Conception, Analyse)
3 - On réalise et on teste (Codage, tests unitaires, intégration)
4 - On vérifie que le produit est conforme à sa définition (Validation).

Pour le moment, on en est toujours au 1... C'est pas grave, mais il faut avancer...

[sone47]

Quelles sont les fonctions que la carte doit réaliser ?
la carte doit ou plutot le mcu doit envoyer des ordres au dsp de facon a realiser des taches,traitement de données fourni ou non par l'user.
Quelles sont les fonctions qui doivent être contrôlées par l'utilisateur ?
l'user doit pouvoir configurer differents parametres (valeur de gains, filtres)
avoir acces a l'etat actuel des parametres et pouvoir choisir la commande qu'il veut utiliser (configurer board, traitement d'un fichier... ), il doit ensuite pouvoir recuperer l'output pour verifier ou decouvrir quelles modifications ont apporté les configs(gain filtre etc)
Quels sont les paramètres de ces fonctions ?
Les fonctions uniquement de configuration ont differents parametres, mais n'ont pas besoin d'etre envoyé sur la board. Apres avoir tout configuré, les parametres utils pour la board sont des mots de 16b a savoir numero de commande,le nbr de parametres et ensuite tout parametres. Il faut aussi pouvoir envoyer des données d'un fichier mais on peut utiliser la meme fonction pour envoyer commande ou datas de fichier.

La liste des commandes est deja definie puisque le menu etait avant embarqué.

[Emmanuel Delahaye]

Quelles sont les fonctions que la carte doit réaliser ?
<...>
La liste des commandes est deja definie puisque le menu etait avant embarqué.

Je ne t'ai pas demandé de me paraphraser, mais de publier clairement et exactement cette fameuse liste. Est-ce si difficile à comprendre ?

[sone47]

L'utilisateur sur le pc doit :
pouvoir connaitre l'etat actuel des gains et valeurs des filtres
modifier ces valeurs s'il le souhaite
lancer la commande play (actuellement c'est un fichier deja chargé qui est lancé)
pouvoir aller modifier les gains pendant que sa play.

Pour connaitre l'etat actuel des gains aucun transfert n'a lieu puisque a l'initialisation,ceux ci sont setter a une valeur defaut et on sauvegarde ensuite les modifs.

La liste des commandes utiles sont:


les commandes :

setGain-->22
setFilter-->23

play-->36


Voici la fonction que doit realiser la carte, ecrire sur le dsp la cmd + parametre:

int Command (U16 nCommand, U16 nParams, U16 Param1 ...)

avec le numero de la commande le nombre de parametres et les parametres.
Le contenu de la fonction permet d'aller ecrire sur le dsp toutes les donnees utiles.

L'utilisateur doit gerer ces fonctions :

saisie des gains:
int Gain (U16 gainIn1, U16 gainIn2, U16 gainIn3, U16 gainIn4)
{
tGain[0]=gainIn1;
tGain[1]=gainIn2;
tGain[2]=gainIn3;
tGain[3]=gainIn4;
return Command (GAIN_CMD, 3, gainIn1, gainIn2, gainIn3, gainIn4);
}
saisie des filtres:
int IIR (U16 nFilter, U16 Coef1, U16 Coef2, U16 Coef3,U16 Coef4, U16 Coef5)
{
tFilter[0]=Coef1;
tFilter[1]=Coef2;
tFilter[2]=Coef3;
tFilter[3]=Coef4;
tFilter[4]=Coef5;
return Command (SET_IIR, 6, nFilter Coef1, Coef2, Coef3, Coef4, Coef5);
}
lancer le play:
int PLAY (U16 Mode, U16 Sample_rate)
{
return Command(PLAY_FILE, 3, 1, Sample_rate);
}

PLAY_FILE, SET_IIR, GAIN_CMD correspondent au numero de commande.

[Emmanuel Delahaye]

L'utilisateur sur le pc doit :
pouvoir connaitre l'etat actuel des gains et valeurs des filtres
modifier ces valeurs s'il le souhaite
lancer la commande play (actuellement c'est un fichier deja chargé qui est lancé)
pouvoir aller modifier les gains pendant que sa play.

Ah, on commence enfin à comprendre ce qu'il y a à faire...

Pour connaitre l'etat actuel des gains aucun transfert n'a lieu puisque a l'initialisation,ceux ci sont setter a une valeur defaut et on sauvegarde ensuite les modifs.

La liste des commandes utiles sont:

les commandes :
setGain-->22
setFilter-->23

play-->36

Ca veut dire quoi -->22 ?

Voici la fonction que doit realiser la carte, ecrire sur le dsp la cmd + parametre:

int Command (U16 nCommand, U16 nParams, U16 Param1 ...)
avec le numero de la commande le nombre de parametres et les parametres.
Le contenu de la fonction permet d'aller ecrire sur le dsp toutes les donnees utiles.

Ca, c'est une commande qui est implémenter dans la partie µC de la carte, on est bien d'accord . Si j'ai bien compris, l'architecture matérielle est ceci :

Code :

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

1
2
3
4
5
6
7
8
 
   PC                            Carte
+-------+                 +-------------------+
|       |                 | +----+     +----+ |
| MENU  |------CDE--------->| µC |<===>| DSP| |
|       |<-----REP----------|    |     +----+ |
|       |                 | +----+            |
+-------+                 +-------------------+

L'utilisateur doit gerer ces fonctions :

saisie des gains:
int Gain (U16 gainIn1, U16 gainIn2, U16 gainIn3, U16 gainIn4)
{
tGain[0]=gainIn1;
tGain[1]=gainIn2;
tGain[2]=gainIn3;
tGain[3]=gainIn4;
return Command (GAIN_CMD, 3, gainIn1, gainIn2, gainIn3, gainIn4);
}
saisie des filtres:
int IIR (U16 nFilter, U16 Coef1, U16 Coef2, U16 Coef3,U16 Coef4, U16 Coef5)
{
tFilter[0]=Coef1;
tFilter[1]=Coef2;
tFilter[2]=Coef3;
tFilter[3]=Coef4;
tFilter[4]=Coef5;
return Command (SET_IIR, 6, nFilter Coef1, Coef2, Coef3, Coef4, Coef5);
}
lancer le play:
int PLAY (U16 Mode, U16 Sample_rate)
{
return Command(PLAY_FILE, 3, 1, Sample_rate);
}

PLAY_FILE, SET_IIR, GAIN_CMD correspondent au numero de commande.

Si je résume bien, les seules fonctions qu'il faut commander par le menu du PC sont :
Commandes d'action

• set-gain gain1 gain2 gain3 gain4
• set-filter coef1 coef2 coef3 coef4 coef5
• play

Commandes d'état

• get-gain
• get-filter

Il n'y a pas de noms plus explicites que ces numéros très abstraits ? Admettons.

On a donc 5 commandes, avec un maximum de 5 paramètres numériques 16-bit.

A partir de ça, il faut définir un protocole fonctionnel :

Code :

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

1
2
3
4
5
6
7
8
 
              PC                          Carte
               |                            |
               |    commande [parametres]   |
Menu.commande  |--------------------------->|Interpreteur-commande.reception
               |                            |
               |    réponse [parametre]     |
Menu.affichage |<---------------------------|Interpreteur-commande.emission

Ensuite, pour chaque commande, il faut définir les réponses possibles :

• set-gain <paramètres> :
  
  • OK
  • ERR-commande-inconnue
  • ERR-paramètres
  • ERR-DSP <erreur>
• set-filter <paramètres> :
  
  • OK
  • ERR-commande-inconnue
  • ERR-paramètres
  • ERR-DSP <erreur>
• play :
  
  • OK
  • ERR-commande-inconnue
  • ERR-DSP <erreur>
• get-gain :
  
  • <informations> OK
  • ERR-commande-inconnue
• get-filter :
  
  • <informations> OK
  • ERR-commande-inconnue

Il me semble qu'il manque les commandes de transfert de fichier, non ?

[sone47]

oui il manquait les fonctions sur les fichiers.
le 22 n'est pas une info essentielle c'était les numeros de commandes actuel

Commandes d'action
set-gain gain1 gain2 gain3 gain4
set-filter coef1 coef2 coef3 coef4 coef5
play
set-input
Commandes d'état
get-gain
get-filter
get-output

et donc les retours:

set-input<paramètres: FILE *, size> :
OK
ERR-commande-inconnue
ERR-paramètres
ERR-transfert
ERR-DSP <erreur>
get-output<paramètres: FILE *, size> :
OK
ERR-commande-inconnue
ERR-paramètres
ERR-transfert
ERR-DSP <erreur>

et merci encore

[Emmanuel Delahaye]

oui il manquait les fonctions sur les fichiers.
le 22 n'est pas une info essentielle c'était les numeros de commandes actuel
et merci encore

OK. Je complète donc la spécification des commandes :


Si je résume bien, les seules fonctions qu'il faut commander par le menu du PC sont :
Commandes d'action

• set-input ???
• set-gain gain1 gain2 gain3 gain4
• set-filter coef1 coef2 coef3 coef4 coef5
• play

Commandes d'état

• get-output
• get-gain
• get-filter

On a donc 6 commandes, avec un maximum de 5 paramètres numériques 16-bit ou des paramètres à définir pour set-file

Ensuite, pour chaque commande, il faut définir les réponses possibles :

• set-input<paramètres> :
  
  • OK
  • ERR-commande-inconnue
  • ERR-paramètres
  • ERR-transfert
  • ERR-DSP <erreur>
• set-gain <paramètres> :
  
  • OK
  • ERR-commande-inconnue
  • ERR-paramètres
  • ERR-DSP <erreur>
• set-filter <paramètres> :
  
  • OK
  • ERR-commande-inconnue
  • ERR-paramètres
  • ERR-DSP <erreur>
• play :
  
  • OK
  • ERR-commande-inconnue
  • ERR-DSP <erreur>
• get-output<paramètres> :
  
  • OK
  • ERR-commande-inconnue
  • ERR-paramètres
  • ERR-transfert
  • ERR-DSP <erreur>
• get-gain :
  
  • <informations> OK
  • ERR-commande-inconnue
• get-filter :
  
  • <informations> OK
  • ERR-commande-inconnue

Attention. Les paramètres de set-file et de get-file ne sont pas clair.

Le suppose que la commande set-file démarre le transfert de fichier. Comment s'opère le transfert de fichier ?

Si j'ai bien compris, il n'y a qu'un tuyau, ou alors, il y a un tuyau de commandes et un tuyau haut débit pour les fichiers ?

Dans ce cas, il faut compéter l'architecture matérielle qu'on y voit clair...

A quoi sert la commande get-file ?

Donc, encore pas mal de questions sur ces 2 commandes...

[sone47]

Elles ne sont pas definies, il y a juste le prototype.
Avant un fichier type sinus était directement enregistré sur la board et l'utilisateur n'avait pas le choix.
Mais j'ai l'adresse ou les données doivent etre ecrites 'AdressIn'
On peut donc facilement ecrire le fichier en memoire partagée a condition que la taille le permette

pc------------->mcu-----------------dsp
envoi file | ecriture en SM

Code :

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

1
2
3
4
5
6
7
8
9
10
 
set_input(char * dataIn, short size)
{
    int i=0;
    Data=U16 * AdressIn;
    for(i=0;(i<size);i++)
    {
        *AdressIn = *dataIn;
    }
}

et pour get_output le meme principe.


Le transfert entre pc et board peut s'effectuer via transmit() [liaison serie] et sur la board on ecrit les datas en memoire partagée.
La fonction getouptut permet de recuperer le fichier et ainsi voir les modifications.
Certes il faut faire attention au debordement de la memoire...

[Emmanuel Delahaye]

Elles ne sont pas definies, il y a juste le prototype.
Avant un fichier type sinus était directement enregistré sur la board et l'utilisateur n'avait pas le choix.
Mais j'ai l'adresse ou les données doivent etre ecrites 'AdressIn'

C'est une adresse 'DSP' ? Elle est connue de l'utilisateur ?

On peut donc facilement ecrire le fichier en memoire partagée a condition que la taille le permette

pc------------->mcu-----------------dsp
envoi file | ecriture en SM

Mémoire partagée (SM = Shared Memory ?) entre le mcu et le DSP ?

Code :

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

1
2
3
4
5
6
7
8
9
10
 
set_input(char * dataIn, short size)
{
    int i=0;
    Data=U16 * AdressIn;
    for(i=0;(i<size);i++)
    {
        *AdressIn = *dataIn;
    }
}

Marche pas. AdressIn n'a jamais été initialisé. De toutes façons, c'est pas le problème. Pour le moment, les détails d'implémentation ne m'intéresse pas. Ça à du mal rentrer...

Ce que je veux savoir, c'est

- Quel est la nature du fichier à transmettre ?
- A quoi sert ce fichier ?
- Comment est-il caractérisé ?
- Quels sont les paramètres que l'on a besoin de transmettre au mcu ?
- Comment sont transmises les données (par quel tuyau) ?

Le transfert entre pc et board peut s'effectuer via transmit() [liaison serie] et sur la board on ecrit les datas en memoire partagée.

OK, j'ai déjà un élément de réponse...

La fonction getouptut permet de recuperer le fichier et ainsi voir les modifications.

Huh ! Qui fait des modifications ? Je crois qu'on a oublié un point essentiel qui clarifierait le tout. Quel est le but exact de ton application ?

Certes il faut faire attention au debordement de la memoire...

OSF...

[sone47]

C'est une adresse 'DSP' ? Elle est connue de l'utilisateur ?

oui cette adresse est connue

Mémoire partagée (SM = Shared Memory ?) entre le mcu et le DSP ?

tout a fait

Marche pas. AdressIn n'a jamais été initialisé. De toutes façons, c'est pas le problème. Pour le moment, les détails d'implémentation ne m'intéresse pas. Ça à du mal rentrer...

AdressIn est figée.
oui desolé...

Ce que je veux savoir, c'est

- Quel est la nature du fichier à transmettre ?
- A quoi sert ce fichier ?
- Comment est-il caractérisé ?
- Quels sont les paramètres que l'on a besoin de transmettre au mcu ?
- Comment sont transmises les données (par quel tuyau) ?

Le fichier est un fichier type pcm.
Ce fichier sert 'test' pour voir l'effet des gains,filtres.
Pour le mcu il faut savoir la taille, le sample rate et le type (mono ou stereo),
mais ces infos sont données dans la commande play (mode et samplerate)

OK, j'ai déjà un élément de réponse...
Huh ! Qui fait des modifications ? Je crois qu'on a oublié un point essentiel qui clarifierait le tout. Quel est le but exact de ton application ?OSF...

L'appli est d'envoyer un fichier, de saisir des configs (gains,filtres), le dsp fait son traitement sur le fichier en SM et on recupere ensuite le tout pour verifier.

[Emmanuel Delahaye]

oui cette adresse est connue

A quoi ça sert que l'utilisateur connaisse cette adresse ? Moins il a de choses ésotériques à manipuler, mieux il se porte...

AdressIn est figée.

Peut être, mais le pointeur n'est pas initialisé... OK, détail d'implémentation, on verra plus tard...

Le fichier est un fichier type pcm.

Ah. Binaire, donc. Quelle taille max ?
Quel est le débit de a liaison série ?

Ce fichier sert 'test' pour voir l'effet des gains,filtres.

Comment ça de test ? Quelle est l'application réelle ?

Pour le mcu il faut savoir la taille, le sample rate et le type (mono ou stereo),
mais ces infos sont données dans la commande play (mode et samplerate)

OK.

L'appli est d'envoyer un fichier, de saisir des configs (gains,filtres), le dsp fait son traitement sur le fichier en SM et on recupere ensuite le tout pour verifier.

OK, je comprends mieux la finalité...

Tu utilises donc le DSP en mode 'différé'. C'est curieux, car en général, on fait plutôt du temps réel avec des flux série rapides... Enfin, c'est ton choix...

Je vais essayer de rédiger une page web qui regroupe les éléments de définitions que je recueille au compte goutte au fur et à mesure...

J'ai commencé :

http://delahaye.emmanuel.free.fr/spip.php?rubrique13