L´envoi du contenu d´un fichier texte vers le port serie RS232 [Résolu]

[arthurdubois]

Salut ,

1- As-tu un appareil et une appli pour tester ton port série. Es-tu certain que c'est le COM1 ?

Reponse: Je crois que je travaille avec le COM1 de mon pc, car c´est avec ce port serie que j´ai effectue les tests avec le microcontrôleur et Hyperterminal. Je vais tout de même me renseigner aupres d´un technicien de l´institut.

2-PS. Peux-tu vérifier ce que tu as dans la base de registres dans HKLM\Hardware\Devicemap\SerialComm ?

Reponse: J´ai clique sur demarrer ---> executer -----> en suite j´ai entre le raccourci suivant: HKLM\Hardware\Devicemap\SerialComm . Mais mon pc m´informe que ce raccourci n´existe pas.

J´essaie actuellement d´effectuer le test que tu m´as conseille. Lors du test j´ai remarque que le microcontrôleur attends que les bytes arrivent dans le buffer UDR0 de l´USART0. Mais UDR0 ne recoit rien. Pour l´envoie des bytes pour le test, j´ai tout simplement deboggue le programme que tu m´as suggere. Es-ce que le debogguage du programme est suffisant pour declencher l´envoie des bytes ?
Ou bien une autre procedure est necessaire pour activer le transfert des bytes. Je travaille avec L´IDE code:blocks sous windows XP.

Merci d´avance

arthurdubois

[Hibernatus34]

Oui le debug suffit.
Mais je comprends pas, comment tu fais pour tester si le CreateFile échoue ?
Le but du test était justement de voir si la connexion est établie. Vérifie dans la doc du µC que tu fais bien tout le nécessaire pour activer l'USART.

Et pour la base de registre, je voulais que tu exécutes "regedit" et que tu regardes dans l'arborescence : HKEY_LOCAL_MACHINE -> HARDWARE -> DEVICEMAP -> SERIALCOMM pour voir quels ports sont définis.

[arthurdubois]

Okay, je vais a nouveau verifier l´USART du microcontrôleur et ensuite j´effectuerais le test de l´echo.

J´ai reussis a avoir acces a l´aborescence que tu m´as divulgue. D´apres l´aborescence, les ports series COM1, COM2 et COM5 sont definies dans mon PC.

[arthurdubois]

Bonsoir Hibernatus34,

J´espere que ton week-end s´est bien deroule et que ta semaine a bien commencee. Quant-a moi, j´ai passe mon temps a essayer d´avancer dans mes travaux et j´ai quand même un peu progresse.

Comme convenu j´ai effectue le test de l´echo pour etablir la communication entre le pc et le microcontrôleur. J´ai obtenu le resultat suivant:

Code :

1
2
3
4
5
6
7
8
9
10
11
12

0 : Pas de reponse ?
1 = 0
2 = 1
3 = 2
4 = 3
5 = 4
6 = 5
7 = 6
8 = 7
9 = 8

A mon avis, la communication a ete etablis entre le microcontrôleur et le pc.

Puis-je maintenant passer au test de l´envoi des positions x et y du fichier texte au microcontrôleur ? Qu´en penses-tu ? Ou dois-je encore ameliorer certains aspects.

Le code c du microcontrôleur qui m´a permis d´effectuer le test d´echo est le suivant:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

#include <avr/io.h>
#include <avr/interrupt.h> 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// #include "uart.h"
#include <avr/pgmspace.h>

#define FOSC 8000000 // Clock Speed
#define BAUD 115200UL

// Berechnungen zur Baudrate:

#define UBRR_VAL ((FOSC+BAUD*8)/(BAUD*16)-1)   // clever runden




/****************************************************/
void USART_Init (unsigned int ubrr)
{
  UBRR0H = (unsigned char)(ubrr>>8);
  UBRR0L = (unsigned char) ubrr;
  UBRR1H = (unsigned char)(ubrr>>8);
  UBRR1L = (unsigned char) ubrr;
  

  UCSR0B = (1<<RXEN0) | (1<<TXEN0) |(0<<RXCIE0)|(0<<TXCIE0);
  UCSR0C = (1<<USBS0) | (0<<UCSZ02)|(1<<UCSZ01)|(1<<UCSZ00);
  UCSR1B = (0<<RXEN1) | (0<<TXEN1) |(0<<RXCIE1)|(0<<TXCIE1);
  UCSR1C = (1<<USBS1) | (0<<UCSZ12)|(1<<UCSZ11)|(1<<UCSZ10);
  
} 

/**********************************************************/

/*-- function receive USART0 --*/

unsigned char USART0_Receive (void)
{
    while(!(UCSR0A & (1<<RXC0)) ); // Attendre la disponibilite du caractere
    
     return UDR0; // Renvoi du caractere se trouvant dans le buffer UDR0
}


/*-- function transmit USART0 --*/

void USART0_Transmit (unsigned char data0)
{
  while ( !(UCSR0A & (1<<UDRE0)) ); // Attendre que l´envoi soit possible 
 
   UDR0 = data0;
} 

/*-- function receive USART1 --*/

unsigned char USART1_Receive (void)
{
  while(!(UCSR1A & (1<<RXC1)) );  // Attendre la disponibilite du caractere
    
   return UDR1; // Renvoi du caractere se trouvant dans le buffer UDR1
}

/*-- function transmit USART1 --*/  

void USART1_Transmit (unsigned char data1)
{
  while ( !(UCSR1A & (1<<UDRE1)) ) ; 
    
   UDR1 = data1; // Envoi de caractere  
}

/**********************************************************/

/*-Activation de l´envoi des positions par le port serie RS485 de USART1-*/

 void RS485_Init (void)
{
  DDRD = (1<<PD4)|(1<<PD3)|(1<<PD5);//activation du pin de sortie et de commande
  PORTD = (1<<PD4);	//port de sortie active (Aktivierung Datensendung)
} 


int main (void)

{ 

  unsigned char c ;

  USART_Init(UBRR_VAL) ;  // USART Initialisierung
  RS485_Init (); // port serie USART1

  while(1)

  {

 

/*-- Test USART0 (Receive and Transmit) --*/
    
 //     USART0_Transmit('X');

    c = USART0_Receive();

    USART0_Transmit(c);
	 

/*-- Test USART1 (Receive and Transmit) --*/

//	USART1_Transmit( 'X' );
//	c = USART0_Receive();
//	USART1_Transmit(c);
	
 
      
  }

}

Merci pour ton aide.

arthurdubois

[Hibernatus34]

On a déjà un petit problème de décalage.
Tu peux tester avec un timeout plus long pour voir ? (25 au lieu de 10)

Sinon, pour le programme complet, il faut que je relise un peu ce qu'on avait dit.
Qu'est-ce qui est le mieux pour toi ?
- Que le PC envoie tout déjà formaté comme "#2C\r" ?
- Ou bien que le PC envoie seulement X,Y et que ça soit le µC qui transforme ça en 2 messages ?

[Mat.M]

Salut pour tout ce qui est communications soit par les ports soit via réseau tu est quasi obligé de faire une architecture en multithreading
Parce que sinon tu vas faire une boucle infinie avec un while() et tu n'auras pas la main dessus.
Le mieux c'est de créer des EVENTS avec CreateEvent(),SetEvent/ResetEvent de mettre les fonctions de lecture et écriture sur le port série dans un thread avec CreateThread().

[arthurdubois]

Bonjour,

concernant le programme complet, j´aimerais qu´on envoie uniquement les positions x, y et ensuite le microcontroleur se chargera de transformer cela en deux messages.

Je vais de ce pas modifier le timeout comme tu me le suggeres afin d´observer si le decalage disparait.

Merci bien

[Mat.M]

Envoyé par arthurdubois

Bonjour,

concernant le programme complet, j´aimerais qu´on envoie uniquement les positions x, y et ensuite le microcontroleur se chargera de transformer cela en deux messages.

je suis bien d'accord mais tu auras des problèmes de synchronisation inévitablement..
Lorsque tu appelles une instruction "envoie sur le port série X et Y", le programme exécuté traite en quelques ms ton instruction et l'envoie au microcontroleur via le port-série.
Cette opération d'envoyer des données par le port-série puis le traitement par le micro C peut prendre plusieurs ms voire des secondes

[arthurdubois]

Salut,

Code :

1
2
3
4
5

je suis bien d'accord mais tu auras des problèmes de synchronisation inévitablement..
Lorsque tu appelles une instruction "envoie sur le port série X et Y", le programme exécuté traite en quelques ms ton instruction et l'envoie au microcontroleur via le port-série.
Cette opération d'envoyer des données par le port-série puis le traitement par le micro C peut prendre plusieurs ms voire des secondes

Dans ce cas, je crois donc qu´il sera preferable que le PC envoie toutes les positions x, y deja formtes sous la forme "#2A\r" au microcontrôleur, afin d´eviter des problemes de synchronisation. Ou bien y a t-il un autre moyen d´eviter le probleme de synchronisation ?

Merci bien.

[arthurdubois]

On a déjà un petit problème de décalage.
Tu peux tester avec un timeout plus long pour voir ? (25 au lieu de 10)

J´ai modifie le timeout comme tu me l´as suggeres, helas le decalage est toujours present. J´ai même pris des valeurs superieurs a 25.

[Hibernatus34]

Envoyé par Mat.M

je suis bien d'accord mais tu auras des problèmes de synchronisation inévitablement..
Lorsque tu appelles une instruction "envoie sur le port série X et Y", le programme exécuté traite en quelques ms ton instruction et l'envoie au microcontroleur via le port-série.
Cette opération d'envoyer des données par le port-série puis le traitement par le micro C peut prendre plusieurs ms voire des secondes

Oui, oui, mais pour l'instant on veut un programme en ligne de commande qui prend un fichier texte et qui balance tout son contenu sur le port série, sans même recevoir de réponse.
Merci de ne pas brûler les étapes.
Par ailleurs, dans mon idée il n'y avait pas de raison que des opérations aussi simples puissent prendre tant de temps. D'ailleurs la cause du décalage pourrait être une erreur de développement, n'ayant jamais eu à développer les 2 bouts, et sachant qu'il peut y avoir du contrôle de flux...

Sinon, pour le choix du format, c'est surtout si le µC est censé connaître les moteurs et pas le PC. Apparemment c'est pas le cas vu qu'on calcule le pas moteur sur le PC. Convertir les commandes me paraît être un boulot suffisamment simple pour un µC, n'exagérons pas. C'est juste ajouter quelques caractères, qu'on envoie de toute façon, donc ça ne fait que rallonger un peu le code.

[Hibernatus34]

Envoyé par arthurdubois

J´ai modifie le timeout comme tu me l´as suggeres, helas le decalage est toujours present. J´ai même pris des valeurs superieurs a 25.

Je vais essayer de comprendre cet après-midi. Mais en désespoir de cause, essaie sans time-out ou avec un très gros time-out (3000). Et tu "kill" le programme si ça ne répond pas au bout de 2 secondes. Je veux être sûr de pas chercher pour rien.

[arthurdubois]

Salut,

Mais en désespoir de cause, essaie sans time-out ou avec un très gros time-out (3000). Et tu "kill" le programme si ça ne répond pas au bout de 2 secondes. Je veux être sûr de pas chercher pour rien.

Ok, je vais suivre ton conseil.

Merci.

[Mat.M]

Envoyé par Hibernatus34

J Et tu "kill" le programme si ça ne répond pas au bout de 2 secondes. Je veux être sûr de pas chercher pour rien.

justement une programmation multithread ça évite de "killer" à l'arrachée comme tu veux faire..!
Si tu fais un while(1) infini tu vois bien que ton programme va boucler indéfiniment !

Envoyé par Hibernatus34

Oui, oui, mais pour l'instant on veut un programme en ligne de commande qui prend un fichier texte et qui balance tout son contenu sur le port série, sans même recevoir de réponse.
Merci de ne pas brûler les étapes.

d'accord pour ne pas brûler les étapes mais on ne peut faire autrement.
J'ai déjà travaillé sur des projets pros et je vois parfaitement que ça ne peut pas fonctionner
Ensuite si tu ne reçois pas de réponse comment veux-tu être synchro ?
Lorsque tu fais de la programmation des E/S tu est confronté à des tâches asynchrones

[Mat.M]

Envoyé par arthurdubois

Ou bien y a t-il un autre moyen d´eviter le probleme de synchronisation ?

Merci bien.

on peut basiquement créer un timer avec SetTimer() ou bien faire des Sleep()
mais ça sera imprécis tu risques de dépasser le temps alloué pour le contrôle.

Un thread c'est une sorte de programme qui va s'exécuter parallèlement à ton programme principal là où il y a ton main()
Donc dans ce programme parallèle fils tu vas appeler une instruction qui va te retourner un code comme quoi la transmission des données a bien été effectuée.
De cette manière tu pourras arrêter une transmission de données si elle est trop longue

Regarder cet exemple du MSDN
http://msdn.microsoft.com/en-us/libr...=vs.85%29.aspx

Canceling Synchronous I/O

[arthurdubois]

Salut,

Hibernatus34, j´ai suivis tes instructions. Helas le decalage est toujours present.

[arthurdubois]

Salut Mat.T,

Merci pour les conseils. Je vais jetter un coup d´oeil au lien que tu as poste.

[Hibernatus34]

Envoyé par Mat.M

on peut basiquement créer un timer avec SetTimer() ou bien faire des Sleep()
mais ça sera imprécis tu risques de dépasser le temps alloué pour le contrôle.

Un thread c'est une sorte de programme qui va s'exécuter parallèlement à ton programme principal là où il y a ton main()
Donc dans ce programme parallèle fils tu vas appeler une instruction qui va te retourner un code comme quoi la transmission des données a bien été effectuée.
De cette manière tu pourras arrêter une transmission de données si elle est trop longue

Regarder cet exemple du MSDN
http://msdn.microsoft.com/en-us/libr...=vs.85%29.aspx

Canceling Synchronous I/O

Rhô... c'est un test ! Et d'ailleurs ce test montre qu'on n'a pas un problème de timing mais un vrai bug. (merci pour ta réponse, arthur)
SetTimer c'est complètement hors de propos car on n'a pas de boucle de messages pour l'instant, et c'est une très mauvaise idée de toute façon (de même que Sleep).
Quant à l'exemple "Canceling Synchronous I/O", je préfère très largement la simplicité d'un time-out, même en multithread, ou bien simplement un polling en attendant une réponse (il y a une fonction pour récupérer le nombre d'octets reçus mais je connais pas bien l'API Win32 pour ça), ou encore WaitCommEvent.

Mais ça c'est pour plus tard... (même pas sûr, selon le boulot qui est demandé à arthur)

[Hibernatus34]

arthurdubois : tu peux poster les 2 codes sources que tu as testés ? (test.c sur le µC et main.cpp sur le PC)

[arthurdubois]

Bonsoir,

desole pour le retard de mon message. il a fallu que j´aille a mon rendez-vous chez le dentiste.

En piece jointe se trouve les deux codes sources.

Je m´escuse encore pour le retard de mon message.

test.c sur le microcontrôleur:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#include <avr/io.h>
#include <avr/interrupt.h> 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// #include "uart.h"
#include <avr/pgmspace.h>
 
#define FOSC 8000000 // Clock Speed
#define BAUD 115200UL
 
// Berechnungen zur Baudrate:
 
#define UBRR_VAL ((FOSC+BAUD*8)/(BAUD*16)-1)   // clever runden
 
 
 
 
/****************************************************/
void USART_Init (unsigned int ubrr)
{
  UBRR0H = (unsigned char)(ubrr>>8);
  UBRR0L = (unsigned char) ubrr;
  UBRR1H = (unsigned char)(ubrr>>8);
  UBRR1L = (unsigned char) ubrr;
 
 
  UCSR0B = (1<<RXEN0) | (1<<TXEN0) |(0<<RXCIE0)|(0<<TXCIE0);
  UCSR0C = (1<<USBS0) | (0<<UCSZ02)|(1<<UCSZ01)|(1<<UCSZ00);
  UCSR1B = (0<<RXEN1) | (0<<TXEN1) |(0<<RXCIE1)|(0<<TXCIE1);
  UCSR1C = (1<<USBS1) | (0<<UCSZ12)|(1<<UCSZ11)|(1<<UCSZ10);
 
} 
 
/**********************************************************/
 
/*-- function receive USART0 --*/
 
unsigned char USART0_Receive (void)
{
    while(!(UCSR0A & (1<<RXC0)) ); // Attendre la disponibilite du caractere
 
     return UDR0; // Renvoi du caractere se trouvant dans le buffer UDR0
}
 
 
/*-- function transmit USART0 --*/
 
void USART0_Transmit (unsigned char data0)
{
  while ( !(UCSR0A & (1<<UDRE0)) ); // Attendre que l´envoi soit possible 
 
   UDR0 = data0;
} 
 
/*-- function receive USART1 --*/
 
unsigned char USART1_Receive (void)
{
  while(!(UCSR1A & (1<<RXC1)) );  // Attendre la disponibilite du caractere
 
   return UDR1; // Renvoi du caractere se trouvant dans le buffer UDR1
}
 
/*-- function transmit USART1 --*/  
 
void USART1_Transmit (unsigned char data1)
{
  while ( !(UCSR1A & (1<<UDRE1)) ) ; 
 
   UDR1 = data1; // Envoi de caractere  
}
 
/**********************************************************/
 
/*-Activation de l´envoi des positions par le port serie RS485 de USART1-*/
 
 void RS485_Init (void)
{
  DDRD = (1<<PD4)|(1<<PD3)|(1<<PD5);//activation du pin de sortie et de commande
  PORTD = (1<<PD4);	//port de sortie active (Aktivierung Datensendung)
} 
 
 
int main (void)
 
{ 
 
  unsigned char c ;
 
  USART_Init(UBRR_VAL) ;  // USART Initialisierung
  RS485_Init (); // port serie USART1
 
  while(1)
 
  {
 
 
 
/*-- Test USART0 (Receive and Transmit) --*/
 
 //     USART0_Transmit('X');
 
    c = USART0_Receive();
 
    USART0_Transmit(c);
 
 
/*-- Test USART1 (Receive and Transmit) --*/
 
//	USART1_Transmit( 'X' );
//	c = USART0_Receive();
//	USART1_Transmit(c);
  
  }
 
}

main.cpp sur le pc:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <fstream>
#include <string>
#include <iostream>
#include <sstream>

#include <Windows.h>

using namespace std;

int main(void)
{
	COMMTIMEOUTS timeouts = { 0 };
	HANDLE h = CreateFile("COM1", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
	if (h == INVALID_HANDLE_VALUE)
	{
		cout << "Erreur: Impossible d´ouvrir le port série" << endl;
		return 1;
	}
 	DCB dcb = { 0 };
	BOOL dcbOk = GetCommState(h, &dcb);
	dcb.BaudRate = CBR_115200;
	dcb.ByteSize = 8;
	dcb.Parity = NOPARITY;
 	dcb.StopBits = TWOSTOPBITS;
	dcbOk = SetCommState(h, &dcb);
	timeouts.ReadIntervalTimeout = 100;
	timeouts.ReadTotalTimeoutMultiplier = 100;
	timeouts.ReadTotalTimeoutConstant = 100;
	timeouts.WriteTotalTimeoutMultiplier = 100;
	timeouts.WriteTotalTimeoutConstant = 100;
	if (!SetCommTimeouts(h, &timeouts))
		return 1;
	// Test de l'écho
	for (int i = 0; i < 5; ++i)
	{
		char sentChar = '0' + i;
		char receivedChar = '#';
		DWORD bytesWritten;
		DWORD bytesRead;
		if (!WriteFile(h, &sentChar, 1, &bytesWritten, 0))
			return 1;
		if (!ReadFile(h, &receivedChar, 1, &bytesRead, 0) || bytesRead != 1)
			cout << sentChar << " : pas de reponse ?" << endl;
		else
			cout << sentChar << " = " << receivedChar << endl;
	}
	CloseHandle(h);
	return 0;
}