Je desire depuis mon PC transmettre le contenu de mon fichier texte au microcontrôleur Atmega 644p. Mon Pc et l´Atmega 644p communiquent a travers l´interface de transmission RS232.
J´ai redige un code en C++ pouvant lire le contenu du fichier Texte. Helas, je n´arrive pas a transmettre le contenu du fichier texte a l´Atmega 644p via la peripherie RS232.
Mon code en integralite est le suivant:
#include <cstdlib>
#include
#include <fstream>
#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <tchar.h>
#include
#include <windows.h>
#include <wtypes.h>
using namespace std;
int main()
{
///////////////////////////////////////////////////////////////////////////
//Lecture du fichier texte et enregistrement dans une chaine de caractere//
///////////////////////////////////////////////////////////////////////////
string koordinaten_zero = "0" ;
char a; // Une variable pour stocker les lignes lues.
string koordinaten_Daten ;
ifstream file; // Un flux entrant sans fichier associe en mode lecture
file.open("koordinaten.txt"); // Ouverture du fichier
if(file)
{
// L´ouverture s´est bien passee. On peut donc lire
while(file) // Tant qu´on n´est pas a la fin, on lit
{
a = file.get();
// cout << a ; // affichage dans la console
koordinaten_Daten.push_back(a); // Ajout de cases supplementaires a la fin du tableau
// cout << koordinaten_Daten << endl ;
}
file.close();
}
else
{
cout << "Erreur: Impossible d´ouvrir le fichier en mode lecture" << endl;
}
/////////////////////////////////////////////////////////////////////////
////////////////////// Traitement du fichier texte //////////////////////
/////////////////////////////////////////////////////////////////////////
int i = 0 ;
while( i < koordinaten_Daten.size()) // Tant que i est inferieur au nombre d´element du tableau
{
// cout << koordinaten_Daten.size() << endl ; // Affichage du nombre d´elements du tableau
if(koordinaten_Daten[i]=='X' && koordinaten_Daten[i+5]=='Y' )
{
koordinaten_Daten.insert(i+1, koordinaten_zero);
}
if(koordinaten_Daten[i]=='Y' && koordinaten_Daten[i+5]=='\n' )
{
koordinaten_Daten.insert(i+1, koordinaten_zero);
}
i++;
}
// cout << koordinaten_Daten ;
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
int k 0, l_x 0, l_y = 0;
float f_x_pos , f_y_pos ;
float f_x 0, f_y 0;
char x_pos[10] = " "; // position suivant l´axe X
char y_pos[10] = " "; // position suivant l´axe Y
unsigned int pasdemoteur_x [500];
unsigned int pasdemoteur_y [500];
char All_Ascii_Pos_x[1000];
char All_Ascii_Pos_y[1000];
while(k < koordinaten_Daten.length())
{
// cout << koordinaten_Daten.length() << endl ;
if(koordinaten_Daten[k] == 'X')
{
for(int j_x=0; j_x<5; j_x++)
{
x_pos[j_x] = koordinaten_Daten[k+j_x+1];
}
f_x_pos = atof (x_pos); // Conversion de ascii en nombre flottant
// cout << f_x_pos << endl ;
f_x = ((f_x_pos*25.4)/10000)*100; // // conversion de la position en pas
// cout << f_x << endl ;
pasdemoteur_x[l_x] = (int)f_x;
// cout << pasdemoteur_x << endl;
l_x++;
}
if(koordinaten_Daten[k] == 'Y')
{
for(int j_y=0; j_y<5; j_y++)
{
y_pos[j_y] = koordinaten_Daten[k+j_y+1];
}
f_y_pos = atof (y_pos); // Conversion ascii en nombre flottant float
// cout << f_y_pos << endl ;
f_y = ((f_y_pos*25.4)/10000)*100; // conversion de la position en pas
// cout << f_y << endl ;
pasdemoteur_y[l_y] = (int)f_y;
// cout << pasdemoteur_y << endl;
l_y++;
}
k++ ;
}
/////////////////////////////////////////////////////////////////////
/////// Transformation des positions X de int en char ////////////////////
/////////////////////////////////////////////////////////////////////
int i_x=0, j_x=0, i_help_x = 0, x1 = 1000 ;
char x[x1] ;
while(i_x<=l_x)
{
itoa(pasdemoteur_x[i_x],x,10);
// cout << x << endl ;
i_x++;
i_help_x += 1 ; // compteur
}
/////////////////////////////////////////////////////////////////////
/////// Transformation Y-position de int en char ////////////////////
/////////////////////////////////////////////////////////////////////
int i_y=0, j_y=0, i_help_y = 0, y1 = 1000 ;
char y[y1] ;
while(i_y<=l_y)
{
itoa(pasdemoteur_y[i_y],y,10);
// cout << y << endl ;
i_y++;
i_help_y += 1 ; // compteur
}
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
Sleep (3000) ; // pause
char * temp_x, *temp_y ;
temp_x = x ;
temp_y = y ;
//cout << temp_x << endl ;
// cout << temp_y << endl ;
/////////////////////////////////////////////////////////////////
//Transmission des positions X et Y vers le port seriel RS232////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
////Initialisation ou configuration du port seriel /////////////
/////////////////////////////////////////////////////////////////
HANDLE h = CreateFile("COM1", // specification du port
GENERIC_READ | GENERIC_WRITE, // lecture, écriture ou les deux
0, // the devide isn't shared.
NULL, // no security attributes
OPEN_EXISTING, // // comm devices must use OPEN_EXISTING
FILE_ATTRIBUTE_NORMAL,
0); // not overlapped I/O
DWORD written = 0;
DCB dcb = { 0 };
BOOL dcbOk = GetCommState(h, &dcb);
//////////////////////////////////////////////////////////////////
////////// Reglage du Baudrate, de la taille du byte,/////////////
//////////du bit de parite, du stopbit////////////////////////////
//////////////////////////////////////////////////////////////////
dcb.BaudRate = CBR_115200; // Specify buad rate of communicaiton.
dcb.ByteSize = 8; // Specify byte of size of communication.
dcb.Parity = NOPARITY; // Specify parity of communication.
dcb.StopBits = TWOSTOPBITS; // Two stop bit
dcb.fOutxCtsFlow = false;
dcbOk = SetCommState(h, &dcb);
DWORD dwModemStatus;
BOOL fCTS;// fDSR, fRING, fRLSD;
int k1 = 0 ;
int control=0 ;
while(k1<(i_help_x))
{
GetCommModemStatus(h, &dwModemStatus);
fCTS = MS_CTS_ON & dwModemStatus;
if (fCTS)
{
if( control == 0 )
{
// Transmission des coordonnees X //
WriteFile(h, // handle to file to write to
temp_x, // pointer to data to write to file
1, // number of bytes to write
&written, // pointer of number of bytes written
0);
cout << "Envoi des coordonnees X" << temp_x << endl;
temp_x++;
Sleep(200);
}
else
{
// Transmission des coordonnees Y //
WriteFile(h, // handle to file to write to
temp_y, // pointer to data to write to file
1, // number of bytes to write
&written, // pointer of number of bytes written
0);
cout << " Envoi des coordonnees Y" << temp_y << endl;
temp_y++;
Sleep(200);
}
}
}
CloseHandle(h);
system ("pause");
return 0;
}
.
Mais la partie du code qui ne marche pas est celui-ci je crois:
/////////////////////////////////////////////////////////////////
//Transmission des positions X et Y vers le port seriel RS232////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
////Initialisation ou configuration du port seriel /////////////
/////////////////////////////////////////////////////////////////
HANDLE h = CreateFile("COM1", // specification du port
GENERIC_READ | GENERIC_WRITE, // lecture, écriture ou les deux
0, // the devide isn't shared.
NULL, // no security attributes
OPEN_EXISTING, // // comm devices must use OPEN_EXISTING
FILE_ATTRIBUTE_NORMAL,
0); // not overlapped I/O
DWORD written = 0;
DCB dcb = { 0 };
BOOL dcbOk = GetCommState(h, &dcb);
//////////////////////////////////////////////////////////////////
////////// Reglage du Baudrate, de la taille du byte,/////////////
//////////du bit de parite, du stopbit////////////////////////////
//////////////////////////////////////////////////////////////////
dcb.BaudRate = CBR_115200; // Specify buad rate of communicaiton.
dcb.ByteSize = 8; // Specify byte of size of communication.
dcb.Parity = NOPARITY; // Specify parity of communication.
dcb.StopBits = TWOSTOPBITS; // Two stop bit
dcb.fOutxCtsFlow = false;
dcbOk = SetCommState(h, &dcb);
DWORD dwModemStatus;
BOOL fCTS;// fDSR, fRING, fRLSD;
int k1 = 0 ;
int control=0 ;
while(k1<(i_help_x))
{
GetCommModemStatus(h, &dwModemStatus);
fCTS = MS_CTS_ON & dwModemStatus;
if (fCTS)
{
if( control == 0 )
{
// Transmission des coordonnees X //
WriteFile(h, // handle to file to write to
temp_x, // pointer to data to write to file
1, // number of bytes to write
&written, // pointer of number of bytes written
0);
cout << "Envoi des coordonnees X" << temp_x << endl;
temp_x++;
Sleep(200);
}
else
{
// Transmission des coordonnees Y //
WriteFile(h, // handle to file to write to
temp_y, // pointer to data to write to file
1, // number of bytes to write
&written, // pointer of number of bytes written
0);
cout << " Envoi des coordonnees Y" << temp_y << endl;
temp_y++;
Sleep(200);
}
}
}
CloseHandle(h);
system ("pause");
return 0;
}
N.B: Dans mon fichier texte, je ne lis que les coordonnees X et Y. Les autres symboles se trouvant dans le fichier texte sont d´aucune utilite pour moi. Bref je desire envoyer progressivement le couple de coordonnes (X,Y) vers l´interface de transmission RS232.
Pourriez-vous, s´il vous plaît jeter un coup d´oeil sur mon programme. Je ne parviens pas a trouver la solution a mon probleme. En fait l´envoi des couples de coordonnees ne marchent pas. Je vous prie de bien vouloir m´aider.
Je travaille sous windows XP avec Code-bloc comme IDE et j´espere que se n´est pas un handicap pour moi. En passant, je suis un debutant en C++.
Merci d´avance.
Arthur.
A voir également:
Envoi du contenu d´un fichier texte vers le port seriel RS232
j ai reussis a deboguer mon code c++ sous windows 7 et jai par la même occasion grâce a laide dun internaute modifier considerable mon programme.
Apres le debogage de mon code C++, jai recu linformation : "Erreur: Impossible douvrir le port série".
Comment pourrais-je ressoudre ce probleme ?
Es-ce que un membre a une idee ? Vos suggestions et corrections sont les bienvenues.
Mon nouveau code:
#include <fstream>
#include <string>
#include
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
using namespace std;
int main(void)
{
ifstream file("koordinaten.txt", ios::in | ios::binary);
string line;
if (!file)
{
cout << "Erreur: Impossible d´ouvrir le fichier en mode lecture" << endl;
return 1;
}
// Ouverture du port COM (c'est votre code tel quel)
HANDLE h = CreateFile("COM1", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (h == INVALID_HANDLE_VALUE)
{
cout << "Erreur: Impossible d´ouvrir le port série" << endl;
return 1;
}
DCB dcb = { 0 };
BOOL dcbOk = GetCommState(h, &dcb);
dcb.BaudRate = CBR_115200;
dcb.ByteSize = 8;
dcb.Parity = NOPARITY;
dcb.StopBits = TWOSTOPBITS;
dcb.fOutxCtsFlow = FALSE; // Pourquoi ça et puis ensuite un test manuel du CTS ?
dcbOk = SetCommState(h, &dcb);
// Lecture ligne par ligne
while (getline(file, line))
{
int x ; // x, y du texte
int y ;
int x_steps; // x, y en pas moteur
int y_steps;
stringstream input; // flux d'entrée (une ligne du texte)
stringstream output_x; // flux de sortie (une paire de coordonnées)
stringstream output_y;
// Une ligne devient un flux d'entrée
input.str(line);
// Extraction du X et du Y.
if (input.get() != 'X')
continue;
input >> x;
//cout << x << endl;
if (input.get() != 'Y')
continue;
input >> y;
//cout << y << endl ;
// cout << x << ", " << y << endl;
// Conversion des positions x et y de integer en pas moteur
// J'ai rendu le calcul compatible avec le type int. (et je le trouve plus lisible)
x_steps = (x * 127) / 500;
//cout << x_steps << endl ;
y_steps = (y * 127) / 500;
//cout << x_steps << ", " << y_steps << endl;
// Envoi des coordonnées par le port série, à compléter car votre code ne permet pas de savoir ce que vous deviez réellement faire.
DWORD written = 0;
output_x << x_steps; // TODO: Ne manque-t-il pas un terminateur ou un cadrage ?
WriteFile(h, output_x.str().c_str(), output_x.str().size(), &written, 0);
output_y << y_steps; // TODO: Ne manque-t-il pas un terminateur ou un cadrage ?
WriteFile(h, output_y.str().c_str(), output_y.str().size(), &written, 0);
// TODO: Et là, il ne faut pas attendre un retour ?
}
CloseHandle(h);
return 0;
}
