Discussion :

[julien terrier]

Bonsoir,

je rencontre un pb lorsque j'essaye d'afficher un caractère en temps réel sur l'écran LCD de ma STM32F429I discovery-board. Pour pouvoir affiché un caractère j'utilise l’hyper-terminal Bray avec un driver FT232R qui communique directement avec ma board la première phase du programme fonctionne, si j'envoie un caractère ou une chaîne de caractère depuis le terminal sur la fenêtre de retour je peux lire ce que j'ai envoyé. Ensuite j'ai intégré la bibliothèque LCD pour pouvoir afficher du texte sur l’écran LCD. Cela fonctionne si les chaines de caractères sont prédéfinis voir exemple du main ci-dessous:

Main.c ( avec chaîne de caractère prédéfinis):

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
int main(void) {
	uint8_t c;
 
	/* Initialize system */
	SystemInit();
 
	  GLCD_Initialize();                         /* GLCD Initialization           */
 
  GLCD_Clear(White);                         /* Clear graphical LCD display   */
  GLCD_SetTextColor(Black);
  GLCD_DisplayString(0, 0, __FI, "Developpez.com"); // ligne 0, colonne 0, Font Index 16x24, chaîne de caractères  
 
 
	/* Initialize USART1 at 9600 baud, TX: PB6, RX: PB7 */
	TM_USART_Init(USART1, TM_USART_PinsPack_2, 9600);
 
 
	while (1) {
		/* Get character from internal buffer */
		c = TM_USART_Getc(USART1);
		if (c) {
			/* If anything received, put it back to terminal */
			TM_USART_Putc(USART1, c);
		}
	}
}

Dans cette configuration sur la première ligne du LCD "Developpez.com" s'affiche et je peux toujours utiliser la fonction hyper-terminal transmit/receive, tout fonctionne.

L'étape suivante est d'implémenter le programme pour que lorsque j'envoie un caractère depuis l'hyper-terminal il s'affiche sur l'écran LCD.

Main.c (implémenter pour afficher un caractère en tps réel):

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
int main(void) {
	uint8_t c;
 
	/* Initialize system */
	SystemInit();
 
	  GLCD_Initialize();                         /* GLCD Initialization           */
 
  GLCD_Clear(White);                         /* Clear graphical LCD display   */
  GLCD_SetTextColor(Black);
  GLCD_DisplayString(0, 0, __FI, "Developpez.com"); // line 0, column 0, Font Index 16x24, string  
 
 
	/* Initialize USART1 at 9600 baud, TX: PB6, RX: PB7 */
	TM_USART_Init(USART1, TM_USART_PinsPack_2, 9600);
 
 
	while (1) {
		/* Get character from internal buffer */
		c = TM_USART_Getc(USART1);
		if (c) {
			 GLCD_DisplayChar(1, 0, __FI, c);
			/* If anything received, put it back to terminal */
			TM_USART_Putc(USART1, c);
		}
	}
}

Et la ça ne fonctionne pas au lieu de m'afficher le caractère tapé ds la console de l'hyper-terminal, il y a un espèce de gribouillis qui n'a aucune signification à l'emplacement ou devrait être écrit le caractère!

Pour ce que ça intéresse voici la fonction qui récupère le caractère ds le buffer:

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
uint8_t TM_USART_Getc(USART_TypeDef* USARTx) {
	int8_t c = 0;
	TM_USART_t* u = TM_USART_INT_GetUsart(USARTx);
 
	/* Check if we have any data in buffer */
	if (u->Num > 0 || u->In != u->Out) {
		/* Check overflow */
		if (u->Out == u->Size) {
			u->Out = 0;
		}
 
		/* Read character */
		c = u->Buffer[u->Out];
 
		/* Increase output pointer */
		u->Out++;
 
		/* Decrease number of elements */
		if (u->Num) {
			u->Num--;
		}
	}
 
	/* Return character */
	return c;
}

Et la fonction qui affiche un caractère:

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
/*******************************************************************************
* Disply character on given line                                               *
*   Parameter:      ln:       line number                                      *
*                   col:      column number                                    *
*                   fi:       font index (0 = 6x8, 1 = 16x24)                  *
*                   c:        ascii character                                  *
*   Return:                                                                    *
*******************************************************************************/
 
void GLCD_DisplayChar (unsigned int ln, unsigned int col, unsigned char fi, unsigned char c) {
 
  c -= 32;
  switch (fi) {
    case 0:  /* Font 6 x 8 */
      GLCD_DrawChar(col *  6, ln *  8,  6,  8, (unsigned char *)&Font_6x8_h  [c * 8]);
      break;
    case 1:  /* Font 16 x 24 */
      GLCD_DrawChar(col * 16, ln * 24, 16, 24, (unsigned char *)&Font_16x24_h[c * 24]);
      break;
  }
}

J'ai constaté qu'en ajoutant un délais avt ou après la fonction d'affichage la lettre frappée ds l'hyper-terminal s'affiche mais seulement le tps du délais après j'ai un rectangle noir qui s'affiche:

Main.c (avec le délais):

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
int main(void) {
	uint8_t c;
 
	/* Initialize system */
	SystemInit();
 
	  GLCD_Initialize();                         /* GLCD Initialization           */
 
  GLCD_Clear(White);                         /* Clear graphical LCD display   */
  GLCD_SetTextColor(Black);
  GLCD_DisplayString(0, 0, __FI, "Devellopez.com"); // line 0, column 0, Font Index 16x24, string  
 
 
	/* Initialize USART1 at 9600 baud, TX: PB6, RX: PB7 */
	TM_USART_Init(USART1, TM_USART_PinsPack_2, 9600);
 
 
	while (1) {
		/* Get character from internal buffer */
		c = TM_USART_Getc(USART1);
		if (c) {
			 GLCD_DisplayChar(1, 0, __FI, c);
			Delay(100000000);
			/* If anything received, put it back to terminal */
			TM_USART_Putc(USART1, c);
		}
	}
}
void Delay(volatile unsigned int delay) {
	for (; delay != 0; delay--);
}

Si quelqu'un a une idée je suis preneur merci pour votre aide!

[Vincent PETIT]

Salut Julien,
A nouveau je pense que tout fonctionne terriblement bien
Peux tu essayer ça et me dire si ça fonctionne ?

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
int main(void) {
	uint8_t c;
	uint8_t ligne = 0;
	uint8_t colonne = 0;
 
 
	/* Initialize system */
	SystemInit();
 
	  GLCD_Initialize();                         /* GLCD Initialization           */
 
  GLCD_Clear(White);                         /* Clear graphical LCD display   */
  GLCD_SetTextColor(Black);
  /*GLCD_DisplayString(0, 0, __FI, "Devellopez.com"); */
 
 
	/* Initialize USART1 at 9600 baud, TX: PB6, RX: PB7 */
	TM_USART_Init(USART1, TM_USART_PinsPack_2, 9600);
 
	while (1) {
 
		c = TM_USART_Getc(USART1);/* Get character from internal buffer */
 
		if(32 <= c && c <= 126) /* caracrères choisis en provenance du PC */
		{
			GLCD_DisplayChar(ligne, colonne, __FI, c);
			colonne += 1;
 
			if(colonne == 16)
				ligne +=1;
 
		}
 
		if(c == 13 || c == 10) /* retour chariot en provenance du PC */
		{
			ligne += 1;
			colonne = 0;
			GLCD_DisplayChar(ligne, colonne, __FI, 0);
		}
 
		if(c == 8) /* touche effacer en provenance du PC */
		{
			GLCD_DisplayChar(ligne, colonne, __FI, 0);
			colonne -= 1;
 
			if(colonne  == 0)
				ligne-=1;
			if(ligne == 0)
				ligne = 0; 
 
		}		
 
 
		/* If anything received, put it back to terminal */
		TM_USART_Putc(USART1, c);
	}
}

[julien terrier]

Salut Vincent, comment je fais le jour ou tu pars en vacances, personne ne me réponds a part toi

Peux tu essayer ça et me dire si ça fonctionne ?

La compilation et le loading sont ok par contre lorsque je lance l'hyper-terminal, avant que je ne tape quoi ce soit il y a sur la fenêtre de retour une ligne entière de <0> qui font planté le terminal du coup il se ferme automatiquement.

Si j'ai bien compris ce que tu as fait, tu as mis des bornes sur les caractères ASCII entre 0 et 126 ensuite on incrémente les colonnes si il y a des nouveaux caractères et quand on arrive a la 16 ème colonnes on passe a la ligne.
(peut être que je me trompe sur le 32 <= c, je le traduis par si c est inférieur ou égal a 32. D'ailleurs je viens de remarqué que les caractères disponible ds la bibliothèque font_16x24_h.h commence a 0x20 soit 32 qui est égale a l'espace, c'est la ou tu voulais en venir? Mettre ds bornes pour que les caractères soit reconnus par le LCD?)

La deuxième partie consiste a prendre en considération les caractères LF(10) et CR(13) comme tu l'indique retour chariot puis BS(8) pour touche effacée!

Je voudrais essayer de mettre le masque "&0x01FF" , ce masque a la même fonction que ce que tu viens de faire il me semble? Sauf que la ça borne entre 256 et 65535. Je souhaiterais essayer avec cette méthode quand pense-tu ? Par contre cela implique de faire une promotion numérique sur uint8_t c en uint16_t c

J'ai essayé ça mais ca ne marche pas:

Code C :

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

1
2
3
4
5
6
7
8
9
while (1) {
		/* Get character from internal buffer */
		c = TM_USART_Getc(USART1);
		if (c) {
			 GLCD_DisplayChar(1, 0, __FI, (uint16_t)(c & 0x01FF));
			/* If anything received, put it back to terminal */
			TM_USART_Putc(USART1, c);
		}
	}

Idem j'ai un rectangle noir a la place de la lettre!

Lol en faite je viens de voir que j'ai dis n'importe quoi ce masque sert a mettre a 0 la variable c et dans le programme le registre USARTx_DR

[Vincent PETIT]

La compilation et le loading sont ok par contre lorsque je lance l'hyper-terminal, avant que je ne tape quoi ce soit il y a sur la fenêtre de retour une ligne entière de <0> qui font planté le terminal du coup il se ferme automatiquement.

ok je pense savoir pourquoi ! J'aurai du y aller par étape et en plus je risque de t'induire en erreur maintenant. Désolé mon pote.

Je reprends depuis le début.
Ton programme fonctionne très bien sauf que dans ton while(1) tu viens sans cesse lire l'UART, qu'il ait un caractère ASCII valide dedans ou pas (n'importe quelle valeur), et tu écris ce caractère au même endroit sur ton LCD !

Code C :

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

1
2
3
GLCD_DisplayChar(1, 0, __FI, c); /* tu écris toujours et au rythme du while(1) sur la ligne 1, colonne 0 */
/* ce qui explique pourquoi avec ta tempo tu vois ce qui se passe mais une fois la tempo passé, hop, tu écrases le caractère avec un autre */
/* le soucis est qu'en lisant sans cesse l'UART, il se peut très bien que tu lises une valeur qui ne correspond a rien puisque tu n'as peut être pas tapé sur ton clavier !!! */

Il faut, un fois que tu as fait l'affichage faire colonne + 1 pour que la nouvelle lecture de l'UART ne vienne pas écraser le catactère affiché !

Tu vois ce que je veux dire ?

[Vincent PETIT]

Si j'ai bien compris ce que tu as fait, tu as mis des bornes sur les caractères ASCII entre 0 et 126 ensuite on incrémente les colonnes si il y a des nouveaux caractères et quand on arrive a la 16 ème colonnes on passe a la ligne. (peut être que je me trompe sur le 32 <= c, je le traduis par si c est inférieur supérieur ou égal a 32. D'ailleurs je viens de remarqué que les caractères disponible ds la bibliothèque font_16x24_h.h commence a 0x20 soit 32 qui est égale a l'espace, c'est la ou tu voulais en venir? Mettre ds bornes pour que les caractères soit reconnus par le LCD?)

La deuxième partie consiste a prendre en considération les caractères LF(10) et CR(13) comme tu l'indique retour chariot puis BS(8) pour touche effacée!

Tu as tout compris, ce sont des gardes fous. Etant donné que tu lis en boucle l'UART, ça veut dire que si tu ne tapes pas sur ton clavier, tu lis quand même une valeur de l'UART (valeur qui peut être celle d'un gribouillis ou n'importe quoi d'autre)

Le but est de ce dire : ok on lit en boucle l'UART mais on va afficher que ce qui est affichable, donc de l'ASCII

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
while (1) {
		c = TM_USART_Getc(USART1);/* lire l'UART et mettre la valeur dans 'c' */
 
		if(32 <= c && c <= 126) /* si la variable 'c', est compris entre 32 et 126 (voir table ASCII) */
		{
			GLCD_DisplayChar(ligne, colonne, __FI, c); /* afficher le caractère c sur le LCD, ligne 0, colonne 0  */
			colonne += 1; /* faire colonne +1 pour le prochain tour */
 
			if(colonne == 16) /* ceci était une limite car je ne connaissais pas ton afficheur, si colonne est arrivé à 16 alors passer a la ligne */
				ligne +=1;
 
		}
...   /* idem pour la gestion des touches Entrée, Effacer etc.... */
...
...

Je pense que là c'est fonctionel :

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
int main(void) {
	uint8_t c;
	uint8_t ligne = 0;
	uint8_t colonne = 0;
 
 
	/* Initialize system */
	SystemInit();
 
	  GLCD_Initialize();                         /* GLCD Initialization           */
 
  GLCD_Clear(White);                         /* Clear graphical LCD display   */
  GLCD_SetTextColor(Black);
/*  GLCD_DisplayString(0, 0, __FI, "Devellopez.com"); // line 0, column 0, Font Index 16x24, string  */
 
 
	/* Initialize USART1 at 9600 baud, TX: PB6, RX: PB7 */
	TM_USART_Init(USART1, TM_USART_PinsPack_2, 9600);
 
 
 
 
	while (1) {
 
		c = TM_USART_Getc(USART1);/* Get character from internal buffer */
 
		if(32 <= c && c <= 126) /* caracrères choisis en provenance du PC */
		{
			GLCD_DisplayChar(ligne, colonne, __FI, c);
			colonne += 1;
 
			if(colonne == 16)
				ligne +=1;
 
			/* écho vers le terminal */
			TM_USART_Putc(USART1, c);
 
		}
 
		if(c == 13 || c == 10) /* retour chariot en provenance du PC */
		{
			ligne += 1;
			colonne = 0;
			GLCD_DisplayChar(ligne, colonne, __FI, 0);
 
			/* écho vers le terminal */
			TM_USART_Putc(USART1, c);
 
		}
 
		if(c == 8) /* touche effacer en provenance du PC */
		{
			GLCD_DisplayChar(ligne, colonne, __FI, 0);
			colonne -= 1;
 
			if(colonne  == 0)
				ligne-=1;
			if(ligne == 0)
				ligne = 0; 
 
			/* écho vers le terminal */
			TM_USART_Putc(USART1, c);
 
		}		
 
	}
}

Dans ma première version l'écho TM_USART_Putc(USART1, c); était dans le while (1) donc forcément j'ai du faire déborder le buffer de l'UART de ton PC en un rien de temps !

Entendons nous bien si mon essai fonctionne, tu me le vires tout de suite et tu le recode toi même. Si tu regardes bien tu peux même faire encore plus efficace !

[julien terrier]

Je te le dis tout de suite ca fonctionne !

Je vais essayer de l'optimiser on va bien voir ce que ça donne.

Un grand merci man je suis pas loin de la vérité !

Premier implémentation avec un switch bof bof je pense qu'il faut plutot travaillé du coté des lignes et des colonnes! je reviens....

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
	while (1) {
		/* Get character from internal buffer */
		c = TM_USART_Getc(USART1);
		if(32 <= c && c <= 126) /* caracrères choisis en provenance du PC */
		{
			GLCD_DisplayChar(ligne, colonne, __FI, c);
			colonne += 1;
 
			if(colonne == 20)
				ligne +=1;
 
			/* é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; 
			/* If anything received, put it back to terminal */
			TM_USART_Putc(USART1, c);
		break;
		case 10:
			ligne += 1;
				colonne = 0;
				GLCD_DisplayChar(ligne, colonne, __FI, 0);
 
			/* écho vers le terminal */
			TM_USART_Putc(USART1, c);
		break;
		case 13:
			ligne += 1;
				colonne = 0;
				GLCD_DisplayChar(ligne, colonne, __FI, 0);
 
			/* écho vers le terminal */
			TM_USART_Putc(USART1, c);
		break;
		}
	}

LCD est en mode paysage ce qui donne 320(width)x240(height) avec une police en 16x24 ca correspond a 20 colonnes!

[Vincent PETIT]

Nickel !
La prochaine fois que je vois que tu as compris et que tu as juste fait une erreur de ce genre (comme écraser sans cesse le même caractère) je ne donnerai pas la réponse mais je te le ferai chercher

C'est vrai que cette rubrique manque de dynamisme et c'est dommage ensuite nous sommes quand même plus sur forum d'informatique que d'électronique. D'où le fait que tu n'aies pas beaucoup de personnes qui repondent. En plus même si il y a des pro de l'embarqué ici, les micro-contrôleurs restent plus dans le giron de l'électronicien. En revenche pose une question sur un Linux embarqué et tu verras que la y a plein de pro.

Il faut que je me dégage du temps mais je souhaite faire quelques tutoriel sur les micro-contrôleurs (Texas Instruments ou atmel ou autre) pour stimuler un peu ceux qui n'oseraient pas ce lancer. J'ai aussi dans l'idée de faire un projet ambitieux à plusieurs "hard/soft + logiciel côté PC" mais pour ça il me faut aussi du temps et des partenaires.

[julien terrier]

Qu'appelles tu Linux embarqué ?

Si je peux t'aider pour ton projet ça serait avec plaisir !

[Vincent PETIT]

Ah ! bah, là je vois que c'est de plus en efficace !
Je pense qu'après tu vas gérer complétement le clavier ?

Etape 1) Grace à la table ASCII tu sera quel touche fait quoi exactement et tu pourra gérer ton LCD comme un vrai éditeur de texte (les touches : insert, fin, debut, page up, page down, les caractères avec accents, la touche entrée, supp etc...)

Etape 2) Gérer le protocole PS/2 d'un clavier comme ça tu relis directement le clavier à ton micro-contrôleur ST sans passer par l'hyperterminal et hop ton micro a un écran LCD (que tu sera piloter à la perfection) + un clavier !

Qu'appel tu Linux embarqué ?

Si je peux t'aider pour ton projet ça serait avec plaisir !

Un Linux embarqué c'est prendre le noyau Linux (sans tout ce qui est graphique) et le faire tourner sur un micro-contrôleur ARM comme le tien. Evidemment avec cette technique, tu n'as plus besoin d'implémenter des bibliothèques à tout va puisqu'elles sont souvent déjà gérées par le noyaux Linux. Après si tu prends la carte Raspberry (tien d'ailleurs faut que je déballe la mienne... depuis le temps) le processeur est tellement puissant, c'est carrément un SOC (micro ARM + processeur video HDMI + plein d'autres choses dans le même CI), qu'ils font tourner une distribution Linux Debian. Mais complète, donc avec un bureau graphique etc... Par contre je trouve qu'on est plus sur de l'informatique a ce niveau là.

Alors, pour mon projet. J'en suis encore qu'a la phase d'étude de faisabilité et de coût car il ne faut pas que j'y laisse ma paye non plus. Il faut aussi que je vois si je n'ai pas mis la barre trop haute non plus car c'est très, voir peut être trop ambitieux. Il s'agit, pour tout te dire, d'un LIDAR. C'est comme un petit radar mais avec un laser.
Si je voulais expliquer simplement :
Tu vois ce que c'est qu'un télémètre laser ? http://www.amazon.fr/s/?ie=UTF8&keyw...l_8ijuuowh97_b Le télémètre possède un emetteur et un récepteur, en gros on envoi un faisceau laser sur quelque chose, il y a une partie du faisceau qui est renvoyée vers le récepteur et le temps qui s'est écoulé entre l'emission et la reception te donne la distance de l'objet que tu visais. Dit comme ça c'est super simple a faire ! Mais en fait pas du tout.

Maintenant imagine que tu fasses tourner ce télémètre sur 360° et tout en prenant des rafales de mesures et que tu affiches ça sur un ecran. Tu aurais une image de ce qui t'entour. Maintenant tu fais tourner le télémètre sur un second axe qui lui aussi fait 360° et pareil tout en prenant des rafales de mesures. Tu serais capable d'afficher à l'écran tout un environnement en 3D. Tu peux regarder sur google des images issus de LIDAR professionnel.
Bien sur ce que je souhaite faire est beaucoup plus modeste mais même en sachant ça. Cela reste très compliqué a mon avis et oui j'espère pouvoir faire ça à plusieurs (pour avoir de l'aide mais aussi car il y a plusieurs domaine particulier a comprendre, d'ailleurs même d'un point de vu du logiciel côté PC ça doit être du costeau!!!!)

[julien terrier]

Ah ! bah, là je vois que c'est de plus en efficace !
Je pense qu'après tu vas gérer complétement le clavier ?

En faite j'ai déjà fait des exercices avec la bibliothèque SDL qui implique une gestion des événements type souris et clavier. Ça se rapproche....

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
 while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
                break;
            case SDL_MOUSEBUTTONDOWN:
                if (event.button.button == SDL_BUTTON_LEFT)
                {
                    // On met l'objet actuellement choisi (mur, caisse...) à l'endroit du clic
                    carte[event.button.x / TAILLE_BLOC][event.button.y / TAILLE_BLOC] = objetActuel;
                    clicGaucheEnCours = 1; // On active un booléen pour retenir qu'un bouton est enfoncé
                }
                else if (event.button.button == SDL_BUTTON_RIGHT) // Le clic droit sert à effacer
                {
                    carte[event.button.x / TAILLE_BLOC][event.button.y /TAILLE_BLOC] = VIDE;
                    clicDroitEnCours = 1;
                }
                break;
            case SDL_MOUSEBUTTONUP: // On désactive le booléen qui disait qu'un bouton était enfoncé
                if (event.button.button == SDL_BUTTON_LEFT)
                    clicGaucheEnCours = 0;
                else if (event.button.button == SDL_BUTTON_RIGHT)
                    clicDroitEnCours = 0;
                break;
            case SDL_MOUSEMOTION:
                if (clicGaucheEnCours) // Si on déplace la souris et que le bouton gauche de la souris est enfoncé
                {
                    carte[event.motion.x / TAILLE_BLOC][event.motion.y / TAILLE_BLOC] = objetActuel;
                }
                else if (clicDroitEnCours) // Pareil pour le bouton droit de la souris
                {
                    carte[event.motion.x / TAILLE_BLOC][event.motion.y / TAILLE_BLOC] = VIDE;
                }
                break;
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        continuer = 0;
                        break;
                    case SDLK_s:
                        sauvegarderNiveau(carte);
                        break;
                    case SDLK_c:
                        chargerNiveau(carte);
                        break;
                    case SDLK_KP1:
                        objetActuel = MUR;
                        break;
                    case SDLK_KP2:
                        objetActuel = CAISSE;
                        break;
                    case SDLK_KP3:
                        objetActuel = OBJECTIF;
                        break;
                    case SDLK_KP4:
                        objetActuel = MARIO;
                        break;
                }
                break;
        }

Après si tu prends la carte Raspberry (tien d'ailleurs faut que je déballe la mienne... depuis le temps) le processeur est tellement puissant, c'est carrément un SOC (micro ARM + processeur video HDMI + plein d'autres choses dans le même CI), qu'ils font tourner une distribution Linux Debian. Mais complète, donc avec un bureau graphique etc... Par contre je trouve qu'on est plus sur de l'informatique a ce niveau là.

On passe ds un niveau supérieur coté développement, j'ai plusieurs fois voulu me diriger vers la Raspeberry pi mais par manque de temps je ne l'ai pas fait... un jour viendra...

Tu as pu récupérer l'article sur la télémétrie ou tu veux que je te l'envoi par mail?

[julien terrier]

Bsr,

j'ai un peu modifié le programme de manière a rafraîchir l'écran lorsque l'on écrit la dernière ligne et j'ai sauté une ligne pour plus de lisibilité .

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
while (1) {
		/* 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 == 35)
				ligne +=1;
 
 
			/* écho vers le terminal */
			TM_USART_Putc(USART1, c);
 
		}
		if(ligne >= 30) {
			{
			 for(i=30; i > 0 ; i--)
 
			GLCD_ClearLn (ligne-i, __FI);
			}
			ligne = 0;
		}
		switch (c) {
 
		case 8:
		GLCD_DisplayChar(ligne, colonne, __FI, 0);
			colonne -= 1;
 
			if(colonne  == 0)
				ligne-=1;
			if(ligne == 0)
				ligne = 0; 
			/* If anything received, put it back to terminal */
			TM_USART_Putc(USART1, c);
		break;
		case 10:
			ligne += 2;
				colonne = 0;
				GLCD_DisplayChar(ligne, colonne, __FI, 0);
 
			/* écho vers le terminal */
			TM_USART_Putc(USART1, c);
		break;
		case 13:
			ligne += 2;
				colonne = 0;
				GLCD_DisplayChar(ligne, colonne, __FI, 0);
 
			/* écho vers le terminal */
			TM_USART_Putc(USART1, c);
		break;
		}
	}
}

Vincent pour optimiser je vais essayer de créer une fonction local qui exécutera le switch, j'ai essayé de créer cette fonction dans un autres fichier src associé au projet mais sans succès (pointeur, tableau), je me rend compte que j'ai vraiment des lacunes en C.

Ensuite j'ai essayé de changer de police de caractère (l'idéal pour moi serait 8x12) mais j'ai seulement réussi a faire fonctionner les polices 6x8 et 16x24 qui étaient associé au projet LCD que j'ai récupéré. Je lâche pas l'affaire des que j'ai du temps j'y retourne lol...

Malgré ces petites optimisations a achever, le projet est fonctionnel je pense le tester in situ cette semaine.

En partie grâce a ton aide merci VP

[Vincent PETIT]

Salut Julien,

je me rend compte que j'ai vraiment des lacunes en C.

T'inquiète pas pour ça ! Elles seront vites comblées surtout au rythme où tu vas.

J'ai vu que le code a bien changé !
Je vais te faire fumer un peu le cerveau (mais je pense que ça pourra te servir pour ton test in-situ... ) Et comment gères l'afficheur LCD lorsqu'il est rempli et que tu es arrivé à la dernière ligne / dernière colonne et que des données arrivent encore ? Et l'historique de l'affichage si jamais tu veux revoir ce qui était écrit à la première ligne alors que tu en as reçu un bon paquet entre temps ?

Je donne un indice ici http://www.developpez.net/forums/d15...l/#post8398377

Ensuite j'ai essayé de changer de police de caractère (l'idéal pour moi serait 8x12) mais j'ai seulement réussi a faire fonctionner les polices 6x8 et 16x24 qui étaient associé au projet LCD que j'ai récupéré. Je lâche pas l'affaire des que j'ai du temps j'y retourne lol...
Malgré ces petites optimisations a achever, le projet est fonctionnel je pense le tester in situ cette semaine.

Ok alors lâche pas ! Et tiens moi au courant.
A+ bétail !

[julien terrier]

Bonsoir,

J'ai regardé le lien que tu as posté, je pense avoir compris le principe de fonctionnement soit découper un grand tableau en X parties ou X correspondra a l'affichage total de mon écran LCD soit 320x240 et donc avec une police de caractère par exemple a 16x24 alors X contiendra 10 lignes d'affichages (X peut-il être lui mm un tableau ou l'on pointe la première ligne puis on lit le tableau X[x]? Ne faut-il pas ds ce cas fonctionner alors avec l'allocation dynamique de mémoire Malloc/calloc ? la c'est sur ça me dépasse hihi ) , bon je sais que si tu m'envoi sur cette piste c'est que forcement c'est réalisable avec mon programme Je vais tenter d'explorer quelques pistes et si tu peux me conseiller je suis preneur.

Par contre je ne sais pas si cela aura une réel valeur ajouté a mon projet d'autant que d'autre alternative s'offre a moi, par exemple mettre une clé usb (ce qui est possible sur la disco-board) afin d’enregistrer les données.

Ensuite j'ai plusieurs question concernant la mémoire du buffer USART:

Code C :

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

1
2
3
4
/* Default buffer size for each USART */
#ifndef USART_BUFFER_SIZE
#define USART_BUFFER_SIZE 				32
#endif

Ceci défini la taille du buffer usart a 32 octets. Ensuite je me demande comment est géré cette taille buffer, a quel moment est-elle remise a 0, et de quel manière peut-on avoir un buffer overflow? sachant que 32 octets ds mon cas correspond a environ 1 ligne et demi? Je pense que la réponse est ds le manuel de référence mais je n'ai pas encore eu le temps de le rererereregarder puis j'ai vu ça:

Code C :

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

1
2
3
4
5
6
7
8
9
10
11
12
* in your project's defines.h file. This will set default length for each buffer.
 * So if you are working with F429 (it has 8 U(S)ARTs) then you will use 8kB RAM if 
 * you set define above to 1024.
 *
 * As of version 2.0, you can now set different buffer sizes for different U(S)ARTs.
 * If you don't change anything, then all USART's have buffer length of value, stored in
 * <code>USART_BUFFER_SIZE</code> define. If you want let's say just for USART1 to be 1kB, but others default value,
 * you can add define below in defines.h file:
@verbatim
//Buffer length for USART1 is 1kB, for others is still TM_USART_BUFFER_SIZE
#define TM_USART1_BUFFER_SIZE 1024
@endverbatim

Donc la taille du buffer USART1 (celui que j'utilise) peut être de 1Ko, une fois que je serais comment fonctionne la remise a zéro alors je comprendrais l’intérêt d'augmenter ça taille...

Ensuite cette acquisition ou est-elle enregistrée j'imagine ds la SRAM du micro et vu que le but de mon projet et de monitorer en permanence il y a un moment ou la mémoire va saturer donc il faut que je trouve un moyen de vider la mémoire sans desalimenter la board, il faut que je comprenne exactement le fonctionnement du micro pour rendre mon programme coherent sans cette compréhension je ne pourrai pas optimiser mon code.

Me reste toujours a modifier cette police de caractère... pas eu le tps de travailler dessus.

Tout ca pour dire que le test in-situ fonctionne avec certes des optimisations comme celle que j'ai cité au-dessus pour que l'affichage soit bien exploitable mais bon ça fonctionne et ça fait plaisir d'aboutir a quelque chose!

Bon je suis parti dans tous les sens mais bon je suis un peu fatigué levé depuis 4h, c'était moi le coq ce matin...

Nb: "a+ bétail" inédit je ne l'avais jamais entendu celle la, je vais te la piquer...

[Vincent PETIT]

Par contre je ne sais pas si cela aura une réel valeur ajouté a mon projet d'autant que d'autre alternative s'offre a moi, par exemple mettre une clé usb (ce qui est possible sur la disco-board) afin d’enregistrer les données.

Ah d'accord ! Je ne savais pas donc oui dans ce cas tout ce que j'ai proposé ne sert pas à grand chose.

J'étais parti du principe où l'écran serait trop petit pour contenir toutes les données reçues via l'USART et tu as bien compris le principe ci dessous

J'ai regardé le lien que tu as posté, je pense avoir compris le principe de fonctionnement soit découper un grand tableau en X parties ou X correspondra a l'affichage total de mon écran LCD soit 320x240 et donc avec une police de caractère par exemple a 16x24 alors X contiendra 10 lignes d'affichages (X peut-il être lui mm un tableau ou l'on pointe la première ligne puis on lit le tableau X[x]? Ne faut-il pas ds ce cas fonctionner alors avec l'allocation dynamique de mémoire Malloc/calloc ? la c'est sur ça me dépasse hihi ) , bon je sais que si tu m'envoi sur cette piste c'est que forcement c'est réalisable avec mon programme Je vais tenter d'explorer quelques pistes et si tu peux me conseiller je suis preneur.

Ne sachant pas combien de données tu vas recevoir par l'USART, tu peux très bien faire de l'allocation dynamique pour agrandir le tableau en mémoire, qui contient les données de l'USART. En prenant garde à ne pas manger toute la mémoire du micro non plus... Si le nombre de données reçues est connu d'avance alors faire un simple grand tableau de taille fixe est faisable aussi. Ensuite comme tu dis, ton afficheur vient lire une partie du tableau de données pour l'afficher. De cette manière tu peux décaler l'affichage vers le bas du tableau de données et l'utilisateur aura l'impression de descendre dans l'historique. En décalant l'affichage vers le haut du tableau de données, l'utilisateur aura l'impression de remonter dans l'historique. Généralement le décalage dont je parle se fait via un scrollbar que tu aurai dessiné sur ton LCD et grâce à deux boutons (haut / bas) l'utilisateur fait descendre ou monter le scrollbar donc l'affichage. Ça donne la même impression que de descendre et de remonter dans un document PDF, par exemple, lorsque tu le regardes sur l'écran de ton PC.

Code C :

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

1
2
3
4
/* Default buffer size for each USART */
#ifndef USART_BUFFER_SIZE
#define USART_BUFFER_SIZE 				32
#endif

Ceci défini la taille du buffer usart a 32 octets. Ensuite je me demande comment est géré cette taille buffer, a quel moment est-elle remise a 0, et de quel manière peut-on avoir un buffer overflow? sachant que 32 octets ds mon cas correspond a environ 1 ligne et demi? Je pense que la réponse est ds le manuel de référence mais je n'ai pas encore eu le temps de le rererereregarder

Code C :

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

1
2
3
4
5
6
7
8
9
10
11
12
* in your project's defines.h file. This will set default length for each buffer.
 * So if you are working with F429 (it has 8 U(S)ARTs) then you will use 8kB RAM if 
 * you set define above to 1024.
 *
 * As of version 2.0, you can now set different buffer sizes for different U(S)ARTs.
 * If you don't change anything, then all USART's have buffer length of value, stored in
 * <code>USART_BUFFER_SIZE</code> define. If you want let's say just for USART1 to be 1kB, but others default value,
 * you can add define below in defines.h file:
@verbatim
//Buffer length for USART1 is 1kB, for others is still TM_USART_BUFFER_SIZE
#define TM_USART1_BUFFER_SIZE 1024
@endverbatim

Donc la taille du buffer USART1 (celui que j'utilise) peut être de 1Ko, une fois que je serais comment fonctionne la remise a zéro alors je comprendrais l’intérêt d'augmenter ça taille...

Je pense aussi qu'il s'agit d'un buffer logiciel et non matériel, je veux bien que le micro soit hyper performant mais de là a ajuster le buffer d'émission/réception materiellement... Je serai très surpris. A mon avis le buffer est vidé une fois qu'une lecture est faite ou un envoi terminé, en supposant que tu es un buffer d’émission et un de réception, et en effet il faudrait regarder la doc du firmware pour comprendre le fonctionnement ! Peut être qu'il s'agit simplement d'une pile, une FIFO logiciel. Si je devais parier je mettrai une pièce la dessus mais au quel cas il faut voir si l'overflow est géré, c'est possible et si ça arrive alors tu perds des données.

Pour s'affranchir de tout ça, le mieux est de travailler en interruption, de cette manière on traite tout de suite et en priorité les octets qui arrivent qui a faire ralentir l'affichage. Sur l'exemple de l'afficheur je n'ai pas l'impression que tu bosses en interruption, on dirait plus du pooling avec un "while(1) lecture USART". En mode interruption tu n'as même pas besoin de buffer. Un octet arrive dans l'USART, la fonction d'interruption le lit et l'envoi illico dans la clé USB sans chercher a comprendre et par exemple, entre deux réceptions tu peux faire de l'affichage sur ton LCD.

Ensuite cette acquisition ou est-elle enregistrée j'imagine ds la SRAM du micro et vu que le but de mon projet et de monitorer en permanence il y a un moment ou la mémoire va saturer donc il faut que je trouve un moyen de vider la mémoire sans desalimenter la board, il faut que je comprenne exactement le fonctionnement du micro pour rendre mon programme coherent sans cette compréhension je ne pourrai pas optimiser mon code.

Tout ca pour dire que le test in-situ fonctionne avec certes des optimisations comme celle que j'ai cité au-dessus pour que l'affichage soit bien exploitable mais bon ça fonctionne et ça fait plaisir d'aboutir a quelque chose!

Nb: "a+ bétail" inédit je ne l'avais jamais entendu celle la, je vais te la piquer...

Si tu peux connecter un clé USB et écrire dedans les données reçues alors c'est le top pour du log en masse comme tu souhaites faire.
Tu dis qu'il y a énormément de données ? Tu as un ordre d'idée ?
C'est parfait si le test a fonctionné ensuite le peaufinent faut voir si ce n'est pas une perte de temps. Par moment le "mieux" est entre le "pas bien" et le "bien".

A+ bétail (ta femme a sûrement déjà du entendre ça )