Discussion :

[julien terrier]

Bonsoir,

j'utilise actuellement un carte de développement STM32 avec un écran LCD pour afficher du texte (code ASCII) provenant d'un device de chargement/déchargement, chaque cycles de chargement et de déchargement contiennent des étapes. A chaque étapes il y a des lignes de texte qui s'écrivent sur l'écran LCD. Il y a donc 4 étapes begin,load,unload,end.
Si il y a un problème lors du chargement ou du déchargement le device retourne un code erreur a la fin de chaque étape et ce code erreur peut etre exploité pour pouvoir dépanner le device.

Si a la fin d'une étape il n' y a pas eu de pb le device remonte cette ligne: --> LPT> 1 LPT>

Par contre si il y a eu une erreur, le code se présente sous cette forme (en code ASCII): --> LPT> 139 LPT> et le code 139 correspond a ce type d'erreur selon la doc constructeur:



L'affichage ressemble a ca:



Ce code erreur est juste un exemple car il y en a environ 300.

Par contre je rencontre un problème lors de l'étape load car si il y a une erreur le device continu d'ecrire sur l'ecran LCD car il finit ses étapes (unload et end) et du coup le code erreur qui a eu lieu est effacé car je réecris par dessus.

Pour contrer ce pb j'ai modifié mon code, si une chaines de caractères correspond a un code erreur, je la compare et si elle sont identique je stoppe mon programme.

CODE C:

Code C :

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
*
 *  Before you start, select your target, on the right of the "Load" button
 *
 *	@author		julien terrier
 *	@email		
 *	@ide		Keil uVision 5
 *	@packs		STM32F4xx Keil packs version 2.2.0 or greater required
 *	@stdperiph	STM32F4xx Standard peripheral drivers version 1.4.0 or greater required
 */
/* Include core modules */
#include "stm32f4xx.h"
/* Include my libraries here */
#include "defines.h"
#include "tm_stm32f4_delay.h"
#include "tm_stm32f4_usart.h"
#include <stdio.h>
#include <string.h>
#include "GLCD.h"
 
/* Pivate function*/
void compare (char *c);
 
#define __FI        0                        /* Font index 6x8              */
#if (__FI == 1)                              /* Font index  16x24               */                         
  #define __FONT_WIDTH  16
  #define __FONT_HEIGHT 24
#else                                        /* Font index 6x8              */
  #define __FONT_WIDTH   6
  #define __FONT_HEIGHT  8
#endif
 
uint8_t continuer = 1;
 
int main(void)
{
	uint8_t  i, a, c = 0, j = 0;
	uint8_t ligne = 1, colonne = 0;
	char chaine1[20] = {""};
 
	/* Initialize system */
	SystemInit();
	/* Initialize delay */
	TM_DELAY_Init();
	GLCD_Initialize();                         /* GLCD Initialization           */
 
  GLCD_Clear(White);                         /* Clear graphical LCD display   */
  GLCD_SetTextColor(Black);
 
	/* Initialize USART1 at 9600 baud, TX: PB6, RX: PB7 */
	TM_USART_Init(USART1, TM_USART_PinsPack_2, 9600);
 
	while (continuer) 
	{	
 
		/* Get character from internal buffer */
		c = TM_USART_Getc(USART1);
 
			if(32 <= c && c <= 126)  /* caractères choisis en provenance du PC */
			{
 
				GLCD_DisplayChar(ligne, colonne, __FI, c);
				colonne += 1;
 
					if(colonne >= 40)
					{
						ligne += 1;
						colonne = 0;
 
					}
					chaine1[j] = c;
					j++;
					/* écho vers le terminal */
					TM_USART_Putc(USART1, c);
			}
 
			switch (c)
			{
 
				case 8:
					GLCD_DisplayChar(ligne, colonne, __FI, 0);
					colonne -= 1;
 
					if(colonne  == 0)
						ligne-=1;
					if(ligne == 0)
						ligne = 0; 
 
					TM_USART_Putc(USART1, c);
				break;
				/* code ASCII retour chariot */	
				case 10:
					compare(chaine1);
					j = 0;
					for (a = 0 ; a < 20 ; a++)
					chaine1[a] = 0;
					ligne += 1;
					colonne = 0;
 
						GLCD_DisplayChar(ligne, colonne, __FI, 0);
					while (TM_USART_BufferEmpty (USART1) != 0)
					{
						TM_USART_ClearBuffer(USART1);
						Delayms(1000);
					}
					/* écho vers le terminal */
					TM_USART_Putc(USART1, c);
				break;
				/* code ASCII retour chariot */	
				case 13:
 
					ligne += 1;
					colonne = 0;
 
					GLCD_DisplayChar(ligne, colonne, __FI, 0);
 
					/* écho vers le terminal */
					TM_USART_Putc(USART1, c);
				break;
			}
 
			switch(ligne) 
			{
 
				case 40:
					for(i=5; i > 0 ; i--)
					/* Rafraichissement de l'ecran on efface la ligne 1 a 5 */
					GLCD_ClearLn (i, __FI);
					ligne = 0;
				break;
 
				case 5:
					for(i=10; i > 5 ; i--)
					/* Rafraichissement de l'ecran, on efface la ligne 6 a 10  */
					GLCD_ClearLn (i, __FI);
					ligne = 5;
				break;
 
				case 10:
					for(i=15; i > 10 ; i--)
					/* Rafraichissement de l'ecran, on efface la ligne 11 a 15  */
					GLCD_ClearLn (i, __FI);
					ligne = 10;
				break;
 
				case 15:
					for(i=20; i > 15 ; i--)				
					/* Rafraichissement de l'ecran, on efface la ligne 16 a 20  */
					GLCD_ClearLn (i, __FI);
					ligne = 15;
				break;
 
				case 20: 
					for(i=25; i > 20 ; i--)
					/* Rafraichissement de l'ecran on efface la ligne 21 a 25 */
					GLCD_ClearLn (i, __FI);
					ligne = 20;
				break;
 
				case 25:
					for(i=30; i > 25 ; i--)
					/* Rafraichissement de l'ecran, on efface la ligne 26 a 30  */
					GLCD_ClearLn (i, __FI);
					ligne = 25;
				break;
 
				case 30:
					for(i=35; i > 30 ; i--)
					/* Rafraichissement de l'ecran on efface la ligne 31 a 35 */
					GLCD_ClearLn (i, __FI);
					ligne = 30;
				break;
 
				case 35:
					for(i=40; i > 35 ; i--)
					/* Rafraichissement de l'ecran on efface la ligne 36 a 40 */
					GLCD_ClearLn (i, __FI);
					ligne = 35;
				break;
			}
	}	
}
 
void compare (char *chaine1)
{
	char chaine3[20] = "--> LPT> 139 LPT>";
 
		Delayms(10);
		if (strcmp(chaine3, chaine1) == 0) // Si chaînes identiques
    {
			continuer = 0;
		}
}

Donc ma question a chaud est, suis-je obligé d'écrire 298 fois :

Code c :

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

1
2
3
4
5
6
7
char chaine3[20] = "--> LPT> 139 LPT>";
 
		Delayms(10);
		if (strcmp(chaine3, chaine1) == 0) // Si chaînes identiques
    {
			continuer = 0;
		}

en modifiant a chaque fois le numéro du code erreur afin de couvrir toutes les erreurs possibles?

Une astuce, la comme ca a chaud je ne vois pas d'autre solution que de tout écrire?

@Vincent Petit une nouvelle fois je viens te solliciter, fais moi rêver !

[Vincent PETIT]

Salut Julien,
Je n'ai pas tout compris car je vois trop de différences entre la capture d'écran de ton fichier log et l'explication. Du coup j'ai des questions !

C'est quoi tout ces LSTAT ? READ_CYCLE_CNT ? Des étapes ?

Donc
Tout est ok :
END
--> LPT> 1 LPT>

Code erreur 139 :
END
--> LPT> 139 LPT>

Et comment tu gères ça par exemple ? Tu en as besoin ou pas ?
READ_CYCLE_CNT
--> LPT> 1 18229 LPT>


Quels sont les mots clés ?


********** fin de mes questions **********
Maintenant je vois, peut être, ce que tu veux faire, c'est "parser" les informations de log et l'algorithme doit différentier tout ça.

Je crois que l'algorithme peut être simplifié en comparant autre chose
Toi tu compares le retour du END avec "--> LPT> 139 LPT>" et si c'est la même chose tu continues.
Ensuite tu seras obligé de faire pareil pour END avec "--> LPT> 140 LPT>" et si c'est la même chose tu continues.
Puis faire pareil pour END avec "--> LPT> 141 LPT>" et si c'est la même chose tu continues.
etc...

Il faudrait que la fonction "compare" soit appelé uniquement lorsqu'on a rencontrer un END.
Ensuite il n'est pas utile de comparer toute cette phrase --> LPT> 140 LPT> car la seule donnée qui nous intéresse c'est juste le chiffre (140 ici)
Si l'algo est bien fait il n'y aurait que ça à lire :
1 -> ok
2 -> erreur 2
3 -> erreur 3
etc....
Comme c'est des chiffre il y a moyen de s'arranger pour stocker moins de phrases.

Je vais attendre tes réponses pour regarder de plus prés.
A toute

[julien terrier]

Salut Julien,
Je n'ai pas tout compris car je vois trop de différences entre la capture d'écran de ton fichier log et l'explication. Du coup j'ai des questions !

C'est quoi tout ces LSTAT ? READ_CYCLE_CNT ? Des étapes ?

Slt Vincent, c'est vraiment un exercice difficile pour moi d'expliquer clairement un problème technique...

Pour répondre a ta première question LSTAT c'est le statut des différents capteurs présents ds le device, READ_CYCLE_CNT c'est un compteur qui s'incrémente si le cycle de chargement/déchargement c'est bien passé et les étapes que j'ai citées elles sont aux nombres de 4 BEGIN / LLDSX1 (load) / ULDSX1 (unload) / END.

Dans mon fichier log l’enchaînement n'est pas vraiment respecté car j'ai fais des tests au moment ou j'ai enregistré ce fichier mais normalement tu dois avoir ces 4 étapes et dans cet ordre avec entre chaque étapes des LSTAT, des READ_CYCLE_CNT so forth...

J'espère que le déroulement est plus clair pour toi, je comprends que c'est difficile de saisir clairement la routine qui se passe, déjà merci d'essayer de comprendre

Donc
Tout est ok :
END
--> LPT> 1 LPT>

Code erreur 139 :
END
--> LPT> 139 LPT>

Et comment tu gères ça par exemple ? Tu en as besoin ou pas ?
READ_CYCLE_CNT
--> LPT> 1 18229 LPT>

Tout a fait si l'étape END s'est déroulé sans incident le device remonte cette phrase --> LPT> 1 LPT> par contre si il y a eu une erreur il y aura un autre numéro a la place de 1.
Mais comme tu peux le constater sur le fichier log après chaque étapes ( BEGIN / LLDSX1 / ULDSX1 / END) il indique si l'étape s'est bien passé et moi je veux scruter après chaque étape voir si il n'y a pas eu une erreur pas seulement sur l'épate END.

READ_CYCLE_CNT est sans intérêt pour moi.

Quels sont les mots clés ?

BEGIN / LLDSX1 / ULDSX1 / END

--> LPT> XXX LPT> ou --> LPT> XX LPT> ou --> LPT> X LPT> ( X = un chiffre entre 0 et 9)


********** fin de mes questions **********

Maintenant je vois, peut être, ce que tu veux faire, c'est "parser" les informations de log et l'algorithme doit différentier tout ça.

Yes sir analyse syntaxique.

Je crois que l'algorithme peut être simplifié en comparant autre chose
Toi tu compares le retour du END avec "--> LPT> 139 LPT>" et si c'est la même chose tu continues.
Ensuite tu seras obligé de faire pareil pour END avec "--> LPT> 140 LPT>" et si c'est la même chose tu continues.
Puis faire pareil pour END avec "--> LPT> 141 LPT>" et si c'est la même chose tu continues.
etc...

Presque sauf que si c'est la même chose (même chaine de caractère) je sors de ma boucle tant que et l’écran reste figé avec le dernier code erreur produit comme ca on peut récupérer le code et travailler sur la panne

Il faudrait que la fonction "compare" soit appelé uniquement lorsqu'on a rencontrer un END.

BEGIN / LLSDX1 / ULSDX1 / END, (la actuellement j'appelle la fonction a chaque fois que l'on va a la ligne.)

Ensuite il n'est pas utile de comparer toute cette phrase --> LPT> 140 LPT> car la seule donnée qui nous intéresse c'est juste le chiffre (140 ici)
Si l'algo est bien fait il n'y aurait que ça à lire :
1 -> ok
2 -> erreur 2
3 -> erreur 3
etc....
Comme c'est des chiffre il y a moyen de s'arranger pour stocker moins de phrases.

Réalisable si je fais un filtre comme tu l'indique sur les 4 étapes parce que ds l'état actuel mon prog s’arrêterait sur un LSTAT comportent un 2 ou READ_CYCLE_CNT = 2, 3 , 4 ........101 so forth..

Encore merci chtio!

NB: ca approche les jumeaux

[julien terrier]

Du coup j'ai commencé a ecrire ca:

Code C :

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
/* code ASCII retour chariot */	
				case 10:
					if (strcmp(chaine3, chaine2) == 0) //  Si la ligne précedente = END
					{
						compare(chaine1); // on compare la ligne actuel
 
						for (d = 0 ; d < 20 ; d++)
							chaine3[d] = 0;              // on réinitialise le tableau chaine3 a 0
					}
 
						for (b=0 ; b < 20 ; b++)
            {
                chaine3[b] = chaine1[b]; // on copie le tableau chaine1 ds le tableau chaine3
            }
						for (a = 0 ; a < 20 ; a++)
							chaine1[a] = 0; // on réinitialise le tableau chaine1 a 0
 
					j = 0;
 
					ligne += 1;
					colonne = 0;
 
						GLCD_DisplayChar(ligne, colonne, __FI, 0);
					while (TM_USART_BufferEmpty (USART1) != 0)
					{
						TM_USART_ClearBuffer(USART1);
						Delayms(1000);
					}
					/* écho vers le terminal */
					TM_USART_Putc(USART1, c);
				break;

ca fonctionne pour END il faut que je le duplique pour BEGIN / LLSDX1 / ULSDX1 et ensuite finir la fonction compare avec tous les chiffres correspondent aux codes erreurs.

Par contre la je suis entrain de voir comment seulement traiter les chiffres et laisser de coter le reste du tableau chaine1.... peut etre la fonction strstr ?

Si tu vois quelque chose de choquant dis le moi !

Merci.

NB: est ce normal qu'il y est une indentation différente lorsque je post ici en comparaison avec celle de mon programme?

[julien terrier]

La fonction compare devient recherche lol

Code C :

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

1
2
3
4
5
6
7
8
9
10
void compare (char *chaine1)
{
	char *suiteChaine;
 
    suiteChaine = strstr(chaine1, "139");
    if (suiteChaine != NULL)
    {
			continuer = 0;
		}
}

Si après la ligne END il y a la chaine de caractère 139 le prog s'arrète !

ON est pas loin du but !

[Vincent PETIT]

Et si tu prends le problème de l'autre sens ?
Si tu arrêtes le prog une fois que la chaine de caractère est différente de 1 ?

Car 1 = ok et toutes les autres valeurs sont des numéros d'erreurs ? Non ?

[julien terrier]

Mais carrément tu me succule ( du verbe succuler, Se dit d'organes végétaux charnus et riches en eau)!

Code C :

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

1
2
3
4
5
6
7
8
9
10
void compare (char *chaine1)
{
	char *suiteChaine;
 
    suiteChaine = strstr(chaine1, " --> LPT> 1 LPT>");
    if (suiteChaine == NULL)
    {
			continuer = 0;
		}
}

[Vincent PETIT]

J'ai du prendre un dictionnaire pour voir ce que voulait dire le verbe succuler !!!!
Il faut quand même essayer tous les cas de figures.

Est ce que :
BEGIN/LOAD/UNLOAD/END est toujours suivie de " --> LPT> x LPT>" (x étant un code) ? N'y a t'il pas un cas de figure tordu où on pourrait avoir autre chose ? Je demande ça car pour LSTAT c'est très différent.

A+

[julien terrier]

Normalement oui, je dis normalement car j'ai pu constater quelques bugs d'affichage du style -> LPT> x LPT> ou sans l'espace du debut bref rien de bien méchant que je ne puisse pas ajouter a la fonction compare, je peux rajouter ces 2 cas de figures afin de ne pas planter le prg! Et scruter afin de voir si il n'y a pas d'autres bugs d'affichage.

[Vincent PETIT]

Ok,
Dans ce cas il suffit peut être simplement de retirer l'espace dans la chaîne de caractères de comparaison (dans la fonction strstr). Au vu du comportement de strstr je pense que ça va fonctionner aussi. Qu'il y ait un espace où non.

Je suppose que tu vas tester ça au boulot la semaine prochaine ?
Tiens moi au courant.
A+ bétail

Ps : pourquoi tu as écrit ça approche les jumeaux ? Tu parles de quoi ?

[julien terrier]

Exact je vais le tester cette semaine!

Ta femme n'attend pas des jumeaux ? pour février ? peut etre que je confonds avec les jumeaux de douchy lol

Un pti gars alors ?

[Vincent PETIT]

non, non, c'est pas des jumeaux (heureusement sinon ça me ferait 5 enfants), fin février j'en aurai 4 et c'est très bien comme ça
C'est une fille cette fois ci !

Ça me fera 3 filles et 1 garçon.

C'est moi qui ait un frère jumeau


ps : C'est quoi comme démo board que tu utilises (quand j'aurai fait le tour de mes 2 micros Texas, ça me tenterait bien une visite chez ST car je n'en n'ai jamais utilisé) ? C'est ça http://www.mouser.com/ds/2/389/DM00218382-775497.pdf ? Et pour les outils de développement, il y en a que je pourrai utiliser sous Linux ?
++

[julien terrier]

non, non, c'est pas des jumeaux (heureusement sinon ça me ferait 5 enfants), fin février j'en aurai 4 et c'est très bien comme ça
C'est une fille cette fois ci !

Ça me fera 3 filles et 1 garçon.

C'est moi qui ait un frère jumeau

Grande famille génial!

ps : C'est quoi comme démo board que tu utilises (quand j'aurai fait le tour de mes 2 micros Texas, ça me tenterait bien une visite chez ST car je n'en n'ai jamais utilisé) ? C'est ça http://www.mouser.com/ds/2/389/DM00218382-775497.pdf ? Et pour les outils de développement, il y en a que je pourrai utiliser sous Linux ?
++

Non j'utilise celle-ci pour mon projet ==> http://www.st.com/web/catalog/tools/...S1532/PF259090.

Mais il y a aussi celle-ci avec d'autre application possible notamment un microphone embarqué ==> http://www.st.com/web/en/catalog/tools/PF261635

Puis l'équivalent d'arduino c'est la nucleo ==> http://www.st.com/web/catalog/tools/...sc=stm32nucleo tu peux choisir selon le µcontroleur que tu veux!

Les prix sont trrès attractif.

Comme IDE j'utilise keil version lite ( 32ko taille max de prog) sinon la version pro fait 4k$ outch, il y a aussi IAR mais je n'ai jamais testé.

En open source il y a coocox, j'ai essayé d'initier un Template pour seulment faire clignoter des leds c'est moins evident qu'avec keil mais bon ca se fait!

Puis le dernier que je connais mais jamais testé viens d'un site ou communauté autour des STM32 ==> http://www.openstm32.org/HomePage j'ai pas eu trop le temps de voir ce que distribué ce site mais apparement tu peux trouver pas mal d'info pour cette gamme de µcontroleur et tu peux utiliser leur IDE "System Workbench for STM32" qui je crois est open source a voir si utilisable sous linux ca je ne sais pas.

J'espère avoir répondu a tes questions!

A+ bétail

[Vincent PETIT]

Okay !
Super merci pour les infos, ça répond a mes questions.
Par contre j'ai intérêt de bien lire les différences entres toutes ces démo board car j'ai l'impression que les différences sont subtiles et résident juste dans le micro-contrôleur mis en oeuvre.

Pour IAR, c'est que j'avais dans mon ancien boulot, franchement c'est aussi bon que Keil et pour le prix c'est franchement aussi bien.... 4k€ aussi pour la licence !!! M'étonnes pas que j'ai choisi GCC pour mes micro Texas

Je vais regarder coocox et openSTM32 pour voir si ça tourne bien sur mon Linux.
Merci et à bientôt pour les résultats de tes tests.

[julien terrier]

Merci et à bientôt pour les résultats de tes tests.

Salut Vincent après reprise et surtout allègement du code l'analyse syntaxique fonctionne du tonnerre!

Je n'ai plus aucun bug a l'affichage et l'analyse syntaxique fonctionne parfaitement!

Merci pour ton aide !

A+ pour de nouvelle aventure!