Aller au contenu


Photo
- - - - -

Port serie c++


  • Veuillez vous connecter pour répondre
13 réponses à ce sujet

#1 bypbop

bypbop

    Habitué

  • Membres
  • PipPip
  • 259 messages
  • Gender:Male
  • Location:Lille

Posté 10 novembre 2011 - 10:02

Bonjour à tous, voila je continue mon petit projet robotique je m'ocuppe de la partie informatique maintenant

Voila je but sur une chose le port serie en c++ sous (microsoft visual studio 2005) j'essaye de trouver des exemples simples pour envoyer et recevoir des infos ...

Est ce que quelqu'un aurait il deja fait cela ?

pour l'instant je detecte les fleches du clavier et j'aimerais envoyer A,Q,D,G en texte via le port serie ...

Mon code C++

// testclavier.cpp : Defines the entry point for the console application.
//
#include <stdafx.h>
#include <stdio.h>
#include <conio.h>

void main(void)
{
    int ch, scan;

    do {
        ch = getch();    /* 1st getch() gets ASCII code */ 
        printf("Character is %d\n", ch);
           if (ch == 0x00 || ch == 0XE0)  { /* if extended key */ 
            scan = getch();  /* 2nd getch() gets "scan code" */ 
			if (scan==72)
			{
			printf("haut\n");
			}
		    if (scan==80)
			{
			printf("bas\n");
			}
			if (scan==75)
			{
			printf("gauche\n");
			}
			if (scan==77)
			{
			printf("droite\n");
			}
			else
			{
			
			}

			printf("\tExtended character:  scan is %d\n", scan);
        
		   
		   }
    }  while (ch != 27);    /* exit loop on ESC */ 
}

Cordialement,
bypbop

#2 Black Templar

Black Templar

    Membre

  • Membres
  • PipPipPipPipPip
  • 1 430 messages
  • Gender:Male
  • Location:Lille

Posté 11 novembre 2011 - 11:12

Salut !

J'ai déjà fait ça.
Si tu es sous Linux, je te conseil d'utiliser la bibliothèque libSerial qui est très bien faite et très simple à utiliser.
Si tu programme sous windows, il te faudra recoder des fonctions de lectures et d'écriture à l'aide de l'API windows. (recevoir et envoyer des infos en RS232, c'est comme lire et écrire dans un fichier !)

J'ai déjà codé ma propre classe de dialogue avec le port série pour windows, mais j'ai encapsuler tout ça dans un thread pour l'utiliser avec le framework graphique Qt. Si ça t'intéresse, je peux poster le code pour que tu vois comment j'ai fait.




Sinon, concernant ton code, tu l'as écrit en C et non en C++...
stdio, c'est une bibliothèque C (il faut utiliser iostream en C++)
gtech et printf sont des fonctions C et non C++


++
Black Templar

Mon site internet : http://ferdinandpiette.com/


#3 bypbop

bypbop

    Habitué

  • Membres
  • PipPip
  • 259 messages
  • Gender:Male
  • Location:Lille

Posté 11 novembre 2011 - 11:17

Bonsoir,

oui merci je veux bien je debute en c++ ca me change bcp ;-)
je code sous windows donc si tu as un bout de code pour que je puisse envoyer et recevoir des infos via le port serie cela m'interesse vivement.

Pour mon code ahh tu m'apprends qqchose ok je vais faire attention au bibliothèque que j'utilise maintenant...
Cordialement,
bypbop

#4 Black Templar

Black Templar

    Membre

  • Membres
  • PipPipPipPipPip
  • 1 430 messages
  • Gender:Male
  • Location:Lille

Posté 11 novembre 2011 - 11:37

Voila les sources de ma bibliothèque : http://ferdinandpiet...232_pour_qt.rar (j'ai aussi mis le code en fin de post)
Tu ne pourras pas l'utiliser telle quelle, mais au moins, ça te permettra de voir les fonctions de l'api windows que j'ai utilisé.

Les méthodes que tu peux regarder en premier sont :
open(
writeCOM(
readCOM(
ainsi que le constructeur QWinSerialPort( pour la configuration initiale

Ensuite, si tu veux encapsuler tout ça dans unthread pour pouvoir écouter le port série en permanance tout en continuant à exécuter ton programme, il te faudra regarder la gestion des évènements et en particulier les méthodes
receiveData(
run(


Si tu souhaites apprendre le C++, je te conseil ce tuto qui est juste LE meilleur : http://www.siteduzer...-langage-c.html


++
Black Templar


Ci dessous, le code :

QWinSerialPort.h
/********************************************************************************
  QWinSerialPort.h :

   Classe de base pour l'envoi et la réception de donner sur un port série RS232.
   Encapsulation dans un Thread pour le framework Qt

   Auteur : Black Templar
********************************************************************************/

#ifndef DEF_QWinSerialPort
#define DEF_QWinSerialPort

#include <windows.h>
#include <QThread>

class QWinSerialPort : public QThread
{
	Q_OBJECT

	public:
    	QWinSerialPort();       			// Constructeur
    	~QWinSerialPort();              	// Déconstructeur

    	int getBaudRate();              	// Retourne le baud rate
    	DCB getDCBConfig();     			// Retourne la configuration DCB actuelle du port COM
    	char getEventChar();            	// Retourne le caractère qui déclanchera le signal eventCharReceived() lorsqu'il est reçu
    	int getReadIntervalTimeout();   	// Retourne le temps d'attente de la fonction read
    	bool isOpen();                  	// Retourne le statut du port
    	QString read();         			// Retourne tout ce qui a été lu depuis le dernier appel de cette méthode

	public slots:
    	bool open(int);             			// Ouvre un port
        	bool setBaudRate(int);          	// Configure le baud rate
        	bool setDCBConfig(DCB); 			// Importe une configuration DCB pour le port série
        	bool setEventChar(char);        	// Configure le caractère qui déclanchera le signal eventCharReceived() lorsqu'il est reçu
        	bool setReadIntervalTimeout(int);   // Configure le temps d'attente de la fonction read
        	bool write(QString);            	// Envoie des données au port
    	void close();               			// Ferme le port

	protected:
    	bool readCOM(void*, int);   		// Lit les données reçu par le port COM
    	void receiveData(DWORD);        	// Remplis le buffer de réception avec les données récupéré par le port COM et lance un signal
    	void run();             			// Active le thread (met le port en mode écoute)
    	bool writeCOM(void*, int);      	// Envoie des données au port

	private:

    	QString a_buffer;
    	COMMTIMEOUTS a_cto;     			// Configuration du port COM
    	DCB a_dcb;                      	// Configuration du port COM
    	HANDLE a_hCOM;                  	// L'identifiant Windows du fichier
    	bool a_open;                    	// Flag d'ouverture du port
    	OVERLAPPED a_overlap;   			// Structure d'erreur du port COM (mode asynchrone)


	signals:
    	void eventCharReceived();   		// Signal annonçant l'arrivée du caractère event (Cf DCB conf)
    	void reading();         			// Signal annonçant l'arrivée de données
    	void error(long);       			// Signal annonçant une erreur
};

#endif // DEF_QWinSerialPort

QWinSerialPort.cpp
/********************************************************************************
  QWinSerialPort.cpp :

   Classe de base pour l'envoi et la réception de donner sur un port série RS232.
   Encapsulation dans un Thread pour le framework Qt

   Auteur : Black Templar
********************************************************************************/

#include "QWinSerialPort.h"
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

/*******************************************************************************
  Définition de constantes
*******************************************************************************/
#define RX_SIZE 		4096	/* taille tampon d'entrée  */
#define TX_SIZE 		4096	/* taille tampon de sortie */
#define MAX_WAIT_READ   5000	/* temps max d'attente pour lecture (en ms)
                       			(mode synchrone : non utilisé ici)   	*/

/******************************************************************************
  QWinSerialPort : Constructeur.
  Initialisation.
******************************************************************************/
QWinSerialPort::QWinSerialPort()
{
	/* Handle du port COM ouvert */
	a_hCOM = NULL;

	/* Délais d'attente sur le port COM */
	a_cto.ReadIntervalTimeout = MAX_WAIT_READ;
	a_cto.ReadTotalTimeoutMultiplier = 0;
	a_cto.ReadTotalTimeoutConstant = MAX_WAIT_READ;
	a_cto.WriteTotalTimeoutMultiplier = 0;
	a_cto.WriteTotalTimeoutConstant = 0;

	/* Configuration du port COM */
	a_dcb.DCBlength = sizeof(DCB);
	a_dcb.BaudRate = CBR_9600;
	a_dcb.fBinary = TRUE;
	a_dcb.fParity = FALSE;
	a_dcb.fOutxCtsFlow = FALSE;
	a_dcb.fOutxDsrFlow = FALSE;
	a_dcb.fDtrControl = DTR_CONTROL_ENABLE;
	a_dcb.fDsrSensitivity = FALSE;
	a_dcb.fTXContinueOnXoff = FALSE;
	a_dcb.fOutX = FALSE;
	a_dcb.fInX = FALSE;
	a_dcb.fErrorChar = FALSE;
	a_dcb.fNull = FALSE;
	a_dcb.fRtsControl = RTS_CONTROL_ENABLE;
	a_dcb.fAbortOnError = FALSE;
	a_dcb.fDummy2 = 0;
	a_dcb.wReserved = 0;
	a_dcb.XonLim = 0x100;
	a_dcb.XoffLim = 0x100;
	a_dcb.ByteSize = 8;
	a_dcb.Parity = NOPARITY;
	a_dcb.StopBits = ONESTOPBIT;
	a_dcb.XonChar = 0x11;
	a_dcb.XoffChar = 0x13;
	a_dcb.ErrorChar = '?';
	a_dcb.EofChar = 0x1A;
	a_dcb.EvtChar = 0x10;   // Important : caractère déclanchant l'évènement eventCharReceived(

	/* Structure récupérant une erreur éventuelle sur le port COM */
	a_overlap.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	a_overlap.Internal = 0;
	a_overlap.InternalHigh = 0;
	a_overlap.Offset = 0;
	a_overlap.OffsetHigh = 0;

	/* Flag d'ouverture du port */
	a_open = false;
}

/******************************************************************************
  ~QWinSerialPort : Déconstructeur.
  Libération de le mémoire
******************************************************************************/
QWinSerialPort::~QWinSerialPort()
{
	if(a_open)  // Si le port COM est ouvert
	{
    	close();	/* Ferme la connection en cours */
    	wait(); 	/* Attend que le processus s'arrête */
	}
	CloseHandle(a_overlap.hEvent);  // Détruit l'évènement erreur sur le port COM
}

/******************************************************************************
  close  : fermeture du port COM.
******************************************************************************/
void QWinSerialPort::close()
{
	/* fermeture du port COM */
	a_open = false;
	if(CloseHandle(a_hCOM))
    	a_hCOM = INVALID_HANDLE_VALUE;
	return;
}

/******************************************************************************
  getDCBConfig  : Retourne le baud rate
  retour    	: baudRate
******************************************************************************/
int QWinSerialPort::getBaudRate()
{
	return a_dcb.BaudRate;
}

/******************************************************************************
  getDCBConfig  : Retourne la configuration DCB actuelle du port COM
  retour    	: DCB configuration
******************************************************************************/
DCB QWinSerialPort::getDCBConfig()
{
	return a_dcb;
}

/******************************************************************************
  getEventChar  : Retourne le caractère qui déclanchera le signal
              	eventCharReceived() lorsqu'il est reçu
  retour    	: le caractère déclancheur d'évènement
******************************************************************************/
char QWinSerialPort::getEventChar()
{
	return a_dcb.EvtChar;
}

/******************************************************************************
  getReadIntervalTimeout  : retourne le temps d'attente de la fonction read
                        	Inutile ici car le port COM est en mode asynchrone
******************************************************************************/
int QWinSerialPort::getReadIntervalTimeout()
{
	return a_cto.ReadIntervalTimeout;
}

/******************************************************************************
  isOpen : Retourne le statut du port.
  retour : vrai si un port COM est ouvert, faux sinon.
******************************************************************************/
bool QWinSerialPort::isOpen()
{
	return a_open;
}

/******************************************************************************
  open   : ouverture et configuration du port COM.
  entrée : id : Id du port COM à ouvrir.
  retour : vrai si l'opération a réussi, faux sinon.
******************************************************************************/
bool QWinSerialPort::open(int id)
{
	/* variables locales */
	char szCOM[16];

	/* Si une connexion existe déjà, on la ferme */
	if(a_open)
    	close();

	/* construction du nom du port, tentative d'ouverture */
	sprintf(szCOM, "COM%d", id);
	a_hCOM = CreateFileA(szCOM, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); //FILE_ATTRIBUTE_SYSTEM
	if(a_hCOM == INVALID_HANDLE_VALUE)
	{
    	return a_open;
	}

	/* affectation taille des tampons d'émission et de réception */
	SetupComm(a_hCOM, RX_SIZE, TX_SIZE);

	/* configuration du port COM */
	if(!SetCommTimeouts(a_hCOM, &a_cto) || !SetCommState(a_hCOM, &a_dcb))
	{
    	CloseHandle(a_hCOM);
    	return a_open;
	}

	/* on vide les tampons d'émission et de réception, mise à 1 DTR */
	PurgeComm(a_hCOM, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
	EscapeCommFunction(a_hCOM, SETDTR);

	a_open = true;
	start();    	/* On active le thread : on met sur écoute le port COM */
	return a_open;
}

/******************************************************************************
  read   : lecture de données reçu du port COM et mis en buffer.
  retour : le buffer qui sera remis à 0 aprés l'appel de la fonction
******************************************************************************/
QString QWinSerialPort::read()
{
	QString r = a_buffer;
	a_buffer.clear();
	return r;
}

/******************************************************************************
  setEventChar  : Configure le baud rate
******************************************************************************/
bool QWinSerialPort::setBaudRate(int baudRate)
{
	/* Le débit doit avoir une valeure prédéfinie */
	switch(baudRate)
	{
    	case CBR_110:
    	case CBR_300:
    	case CBR_600:
    	case CBR_1200:
    	case CBR_2400:
    	case CBR_4800:
    	case CBR_9600:
    	case CBR_14400:
    	case CBR_19200:
    	case CBR_38400:
    	case CBR_57600:
    	case CBR_115200:
    	case CBR_128000:
    	case CBR_256000:
        	break;
    	default:
        	return false;
	}

	a_dcb.BaudRate = baudRate;
	if(a_open)
	{
    	return SetCommState(a_hCOM, &a_dcb);
	}

	return true;
}
/******************************************************************************
  setDCBConfig  : Importe une configuration DCB pour le port série
******************************************************************************/
bool QWinSerialPort::setDCBConfig(DCB dcb)
{
	a_dcb = dcb;	//EST CE QUE CEST BON ???? JE NE SAIS PU SI ON PEUT FAIRE CA §§§§§§§§§§§ :s
	if(a_open)
	{
    	return SetCommState(a_hCOM, &a_dcb);
	}

	return true;
}

/******************************************************************************
  setEventChar  : Configure le caractère qui déclanchera le signal eventCharReceived() lorsqu'il est reçu
******************************************************************************/
bool QWinSerialPort::setEventChar(char c)
{
	a_dcb.EvtChar = c;
	if(a_open)
	{
    	return SetCommState(a_hCOM, &a_dcb);
	}

	return true;
}

/******************************************************************************
  setReadIntervalTimeout  : Configure le temps d'attente de la fonction read
                        	Inutile en mode asynchrone
******************************************************************************/
bool QWinSerialPort::setReadIntervalTimeout(int readIntervalTimeout)
{
	a_cto.ReadIntervalTimeout = readIntervalTimeout;
	if(a_open)
	{
    	return SetCommTimeouts(a_hCOM, &a_cto);
	}

	return true;
}

/******************************************************************************
  write  : écriture d'une chaine sur le port COM.
  entrée : s	: la chaine à transmettre
  retour : vrai si l'opération a réussi, faux sinon.
******************************************************************************/
bool QWinSerialPort::write(QString s)
{
	/* Initialisation du buffer */
	char *buffer = NULL;
	buffer = (char*)malloc((s.length()+1) * sizeof * buffer);

	/* Rempli le buffer */
	int i = 0;
	QChar *data = s.data();
	while (!data->isNull())
	{
 		buffer[i] = data->toAscii();
 		data++;
 		i++;
	}
	buffer[i] = '\0';

	/* Transmet le buffer au port COM */
	return writeCOM(buffer, i);
}

/******************************************************************************
  read   : lecture de données sur le port COM.
  entrée : buffer   	: buffer où mettre les données lues.
   		nBytesToRead : nombre max d'octets à lire.
   		pBytesRead   : variable qui va recevoir le nombre d'octets lus.
  retour : vrai si l'opération a réussi, faux sinon.
-------------------------------------------------------------------------------
  Remarques : - la constante MAX_WAIT_READ utilisée dans la structure
            	COMMTIMEOUTS permet de limiter le temps d'attente si aucun
            	caractères n'est présent dans le tampon d'entrée.
          	- la fonction peut donc retourner vrai sans avoir lu de données.
******************************************************************************/
bool QWinSerialPort::readCOM(void* buffer, int nBytesToRead)
{
	/* Structure évènement erreur sur la lecture */
	OVERLAPPED overlapRead;
	overlapRead.Internal = 0;
	overlapRead.InternalHigh = 0;
	overlapRead.Offset = 0;
	overlapRead.OffsetHigh = 0;
	overlapRead.hEvent = CreateEvent(NULL, true, false, NULL);

	/* Lecture du port */
	bool result = ReadFile(a_hCOM, buffer, nBytesToRead, NULL, &overlapRead);
	ResetEvent(overlapRead.hEvent); // Supression de l'évènement erreur sur la lecture

	return result;
}

/******************************************************************************
  receiveData   : Récupère les données envoyés par le port COM
******************************************************************************/
void QWinSerialPort::receiveData(DWORD event)
{
	/* Attention, méthode non testé à fond ...
   	A débugger si utilisé ! */
	QString q;
	char buffer[2]; // Récupère un seul caractère
	buffer[0] = '\0';
	DWORD Errors;
	COMSTAT Status;
	do
	{
    	if(readCOM(buffer, 1))
    	{
        	if(buffer[0] != a_dcb.EvtChar)// | true)
        	{
            	buffer[1] = '\0';
            	a_buffer += QString(buffer);
        	}
    	}
    	ClearCommError(a_hCOM, &Errors, &Status);
	}
	while(Status.cbInQue > 0); // Est-ce que c'est disposible en mode asynchrone ?

	switch(event)
	{
    	case EV_RXCHAR:
        	emit reading(); 			// Emission d'un signal de lecture du port COM
        	break;
    	case EV_RXFLAG:
        	emit eventCharReceived();   // Emission du signal indiquant que le caratère spécial à été lu
        	break;
	}
}

/******************************************************************************
  run   : Active le thread
      	Met le port COM en mode écoute
******************************************************************************/
void QWinSerialPort::run()
{
	/* Récupère les évènement de lecture d'un caractèr et de lecture d'un caractère spécial */
	SetCommMask(a_hCOM, EV_RXCHAR | EV_RXFLAG | EV_BREAK);
	DWORD event = 0;

	/* On attend qu'un événement sur le port COM se produisse */
	while(a_open)
	{
    	event = 0;
    	ResetEvent(a_overlap.hEvent);
    	if(!WaitCommEvent(a_hCOM, &event, &a_overlap))
    	{
        	if (GetLastError() != ERROR_IO_PENDING)
        	{
            	//close();
            	//return;
        	}
    	}

    	if(WaitForSingleObject(a_overlap.hEvent, INFINITE) == WAIT_OBJECT_0)
    	{
        	//overlap event occured
        	DWORD undefined;
        	if (!GetOverlappedResult(a_hCOM, &a_overlap, &undefined, false))
        	{
            	emit error(GetLastError());
            	//qWarning("Comm event overlapped error %ld", GetLastError());
            	close();
            	return;
        	}


        	/* Données reçue via le port COM */
        	if(event & EV_RXCHAR == EV_RXCHAR)
            	receiveData(EV_RXCHAR);
        	if((event & EV_RXFLAG) == EV_RXFLAG)
            	receiveData(EV_RXFLAG);
        	//if(event & EV_BREAK == EV_BREAK)
            	//close();
    	}
	}
}

/******************************************************************************
  write  : envoi de données sur le port COM.
  entrée : buffer    	: buffer avec les données à envoyer.
   		nBytesToWrite : nombre d'octets à envoyer.
   		pBytesWritten : variable qui va recevoir le nombre d'octets
               			envoyés.
  retour : toujours vrai (vrai si l'opération a réussi, faux sinon
                      	valable en mode synchrone uniquement)
******************************************************************************/
bool QWinSerialPort::writeCOM(void* buffer, int nBytesToWrite)
{
	OVERLAPPED overlapWrite;
	overlapWrite.Internal = 0;
	overlapWrite.InternalHigh = 0;
	overlapWrite.Offset = 0;
	overlapWrite.OffsetHigh = 0;
	overlapWrite.hEvent = CreateEvent(NULL, true, false, NULL);
	/* écriture sur le port */
	bool result = WriteFile(a_hCOM, buffer, nBytesToWrite, NULL, &overlapWrite);	// Always false because : asynchronous
	ResetEvent(overlapWrite.hEvent);

	return true;
}

Mon site internet : http://ferdinandpiette.com/


#5 bypbop

bypbop

    Habitué

  • Membres
  • PipPip
  • 259 messages
  • Gender:Male
  • Location:Lille

Posté 12 novembre 2011 - 12:18

Merci bcp je regarde ca ;-)


Merci bcp
Cordialement,
bypbop

#6 x-programer

x-programer

    Nouveau membre

  • Membres
  • 24 messages

Posté 12 novembre 2011 - 10:11

merci pour le code ça peut m'aider moi aussi, j'ai une question ! comment envoyer une petit pgm qui allume une LED avec ta bib ???
Merci d'avance.

#7 Black Templar

Black Templar

    Membre

  • Membres
  • PipPipPipPipPip
  • 1 430 messages
  • Gender:Male
  • Location:Lille

Posté 13 novembre 2011 - 03:41

merci pour le code ça peut m'aider moi aussi, j'ai une question ! comment envoyer une petit pgm qui allume une LED avec ta bib ???
Merci d'avance.


Salut !
Comme je l'ai mis plus haut, cette bibliothèque est un peu spéciale car elle a été conçu spécialement pour être utilisé sous windows avec le framework graphique Qt. Donc si tu es sous windows et que tu utilises Qt, tout vas bien, tu peux l'utiliser, sinon, il te faudra réécrite ta propre bibliothèque en t'inspirant de ce que j'ai fait.

Pour l'utilisation, j'ai encapsulé ma classe dans un thread. L'intérêt, c'est que lorsque je me connecte à un port COM (à l'aide de la méthode open), le lance le thread (start() de la méthode run() ) dont la mission est d'écouter en permanence tout évènement qui se passe au niveau de la communication série. Lorsqu'une donnée est reçu, la méthode receiveData() puis readCOM() sont appelées pour récupérer les données et les stocker dans un buffer automatiquement.

L'utilisateur, quant à lui, peut récupéré les données stockés dans le buffer grâce à la méthode read() et peut envoyer des infos grâce à la méthode write().

close() sert à arrêter le thread et à fermer la communication.

En gros, les méthodes les plus importantes sont open(, read(, write( et close(.
Ensuite, setDCBConfig( et setBaudRate( peuvent être intéressante pour configurer la communication (par défaut, on est en 9600bau, pas de bit de parité, un bit de stop et 8 octets de données)

++
Black Templar

Mon site internet : http://ferdinandpiette.com/


#8 x-programer

x-programer

    Nouveau membre

  • Membres
  • 24 messages

Posté 13 novembre 2011 - 02:31

merci pour ta réponse, et ben je n'utilise pas la bib Qt donc je vais réimplémenter ma propre bib !
Je vous demande de mettre un simple pgm(en c++) pour allumer un led et l'injecter?
merci encore.

#9 Black Templar

Black Templar

    Membre

  • Membres
  • PipPipPipPipPip
  • 1 430 messages
  • Gender:Male
  • Location:Lille

Posté 13 novembre 2011 - 02:44

bah coté pc tu ouvre une communication COM, tu envois un code pour alumer une led
côté microcontroleur, tu ouvres une communication COM, tu recoit les données et tu les interprètes.


Par exemple (code pondu de tête et non testé). Une communication initialisé sur le port com 5 à 9600bau.
Un 1 déclenche l'allumage d'une LED sur la pin 13 de l'arduino.

fonction main côté PC :
void main(void)
{
	QWinSerialPort portCom;
	portCom.open(5);
	portCom.write("1");
	portCom.close();

	return;
}

Côté Arduino :
void setup()
{
	pinMode(13, OUTPUT);
	digitalWrite(13,LOW);
	Serial.begin(9600);
}

void loop()
{
	if(Serial.isAvailable())
	{
    	val = Serial.read();
    	if(val == "1")
        	digitalWrite(13,HIGH);
	}
}


++
Black Templar

Mon site internet : http://ferdinandpiette.com/


#10 x-programer

x-programer

    Nouveau membre

  • Membres
  • 24 messages

Posté 13 novembre 2011 - 05:55

bah coté pc tu ouvre une communication COM, tu envois un code pour alumer une led
côté microcontroleur, tu ouvres une communication COM, tu recoit les données et tu les interprètes.


Par exemple (code pondu de tête et non testé). Une communication initialisé sur le port com 5 à 9600bau.
Un 1 déclenche l'allumage d'une LED sur la pin 13 de l'arduino.

fonction main côté PC :

void main(void)
{
	QWinSerialPort portCom;
	portCom.open(5);
	portCom.write("1");
	portCom.close();

	return;
}

Côté Arduino :
void setup()
{
	pinMode(13, OUTPUT);
	digitalWrite(13,LOW);
	Serial.begin(9600);
}

void loop()
{
	if(Serial.isAvailable())
	{
    	val = Serial.read();
    	if(val == "1")
        	digitalWrite(13,HIGH);
	}
}


++
Black Templar


merci bcp maintenant j'ai une idée sur la prog de pic, et je peut commencer dans ce processus !
encore merci pour l'aide.

#11 bypbop

bypbop

    Habitué

  • Membres
  • PipPip
  • 259 messages
  • Gender:Male
  • Location:Lille

Posté 13 novembre 2011 - 06:26

Bonjour x-programmer,

Maintenant j'ai bien compris .En fait il a une bibliothèque et tu puises dedans les fonctions ouverture et envoi en passant des paramètres ...
Mais comme je n'ai jamais fait ca je ne sais pas comment je dois faire pour incorporer cette bibliotèque à mon projet.

Je vois qu'il y a un fichier QWinSerialPort.h et QWinSerialPort.cpp

Quand je suis dans mon projet testclavier.cpp visual studio 2005 peux tu m'expliquer comment et quel type de fichier je dois creer pour les incorporer.

Encore Merci,
bypbop

#12 Black Templar

Black Templar

    Membre

  • Membres
  • PipPipPipPipPip
  • 1 430 messages
  • Gender:Male
  • Location:Lille

Posté 13 novembre 2011 - 06:47

Pour ça, il faut que tu lise ce tuto en entier : http://www.siteduzero.com/tutoriel-3-11406-programmez-avec-le-langage-c.html

Mon site internet : http://ferdinandpiette.com/


#13 bypbop

bypbop

    Habitué

  • Membres
  • PipPip
  • 259 messages
  • Gender:Male
  • Location:Lille

Posté 13 novembre 2011 - 07:20

Bonsoir Black Templar,

dslé tout à l heure mon message etait pour toi ;-)

alors je viens d'ajouter les sources existantes j'ai trouvé un tutoriel qui explique comment le faire sous visual studio alors j'ai ajouté directement
les sources du rar le .cpp et le .h je l'ai ai bien dans mon projet maintenant j'ai ajoute au 2 fichiers #include <stdafx.h> et je n'appelle pas encore les fonctions dans mon fichier Main > Je compile pour test mais la catastrophe plein d'erreur ...

Erreur	1	error C3861: 'getch' : identificateur introuvable	c:\documents and settings\administrateur\bureau\c++\testclavier\testclavier.cpp	13	
Erreur	2	error C3861: 'printf' : identificateur introuvable	c:\documents and settings\administrateur\bureau\c++\testclavier\testclavier.cpp	14	
Erreur	3	error C3861: 'getch' : identificateur introuvable	c:\documents and settings\administrateur\bureau\c++\testclavier\testclavier.cpp	16	
Erreur	4	error C3861: 'printf' : identificateur introuvable	c:\documents and settings\administrateur\bureau\c++\testclavier\testclavier.cpp	19	
Erreur	5	error C3861: 'printf' : identificateur introuvable	c:\documents and settings\administrateur\bureau\c++\testclavier\testclavier.cpp	23	
Erreur	6	error C3861: 'printf' : identificateur introuvable	c:\documents and settings\administrateur\bureau\c++\testclavier\testclavier.cpp	27	
Erreur	7	error C3861: 'printf' : identificateur introuvable	c:\documents and settings\administrateur\bureau\c++\testclavier\testclavier.cpp	31	
Erreur	8	error C3861: 'printf' : identificateur introuvable	c:\documents and settings\administrateur\bureau\c++\testclavier\testclavier.cpp	38	
Erreur	9	error C2653: 'QWinSerialPort' : n'est pas un nom de classe ni d'espace de noms	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	29	
Erreur	10	error C4430: spécificateur de type manquant - int est pris en compte par défaut. Remarque : C++ ne prend pas en charge int par défaut	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	30	
Erreur	11	error C2065: 'a_hCOM' : identificateur non déclaré	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	32	
Erreur	12	error C2065: 'NULL' : identificateur non déclaré	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	32	
Erreur	13	error C2065: 'a_cto' : identificateur non déclaré	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	35	
Erreur	14	error C2228: la partie gauche de '.ReadIntervalTimeout' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	35	
Erreur	15	error C2228: la partie gauche de '.ReadTotalTimeoutMultiplier' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	36	
Erreur	16	error C2228: la partie gauche de '.ReadTotalTimeoutConstant' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	37	
Erreur	17	error C2228: la partie gauche de '.WriteTotalTimeoutMultiplier' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	38	
Erreur	18	error C2228: la partie gauche de '.WriteTotalTimeoutConstant' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	39	
Erreur	19	error C2065: 'a_dcb' : identificateur non déclaré	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	42	
Erreur	20	error C2228: la partie gauche de '.DCBlength' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	42	
Erreur	21	error C2065: 'DCB' : identificateur non déclaré	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	42	
Erreur	22	error C2070: ''unknown-type'' : opérande sizeof non conforme	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	42	
Erreur	23	error C2228: la partie gauche de '.BaudRate' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	43	
Erreur	24	error C2065: 'CBR_9600' : identificateur non déclaré	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	43	
Erreur	25	error C2228: la partie gauche de '.fBinary' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	44	
Erreur	26	error C2065: 'TRUE' : identificateur non déclaré	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	44	
Erreur	27	error C2228: la partie gauche de '.fParity' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	45	
Erreur	28	error C2065: 'FALSE' : identificateur non déclaré	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	45	
Erreur	29	error C2228: la partie gauche de '.fOutxCtsFlow' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	46	
Erreur	30	error C2228: la partie gauche de '.fOutxDsrFlow' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	47	
Erreur	31	error C2228: la partie gauche de '.fDtrControl' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	48	
Erreur	32	error C2065: 'DTR_CONTROL_ENABLE' : identificateur non déclaré	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	48	
Erreur	33	error C2228: la partie gauche de '.fDsrSensitivity' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	49	
Erreur	34	error C2228: la partie gauche de '.fTXContinueOnXoff' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	50	
Erreur	35	error C2228: la partie gauche de '.fOutX' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	51	
Erreur	36	error C2228: la partie gauche de '.fInX' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	52	
Erreur	37	error C2228: la partie gauche de '.fErrorChar' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	53	
Erreur	38	error C2228: la partie gauche de '.fNull' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	54	
Erreur	39	error C2228: la partie gauche de '.fRtsControl' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	55	
Erreur	40	error C2065: 'RTS_CONTROL_ENABLE' : identificateur non déclaré	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	55	
Erreur	41	error C2228: la partie gauche de '.fAbortOnError' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	56	
Erreur	42	error C2228: la partie gauche de '.fDummy2' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	57	
Erreur	43	error C2228: la partie gauche de '.wReserved' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	58	
Erreur	44	error C2228: la partie gauche de '.XonLim' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	59	
Erreur	45	error C2228: la partie gauche de '.XoffLim' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	60	
Erreur	46	error C2228: la partie gauche de '.ByteSize' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	61	
Erreur	47	error C2228: la partie gauche de '.Parity' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	62	
Erreur	48	error C2065: 'NOPARITY' : identificateur non déclaré	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	62	
Erreur	49	error C2228: la partie gauche de '.StopBits' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	63	
Erreur	50	error C2065: 'ONESTOPBIT' : identificateur non déclaré	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	63	
Erreur	51	error C2228: la partie gauche de '.XonChar' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	64	
Erreur	52	error C2228: la partie gauche de '.XoffChar' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	65	
Erreur	53	error C2228: la partie gauche de '.ErrorChar' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	66	
Erreur	54	error C2228: la partie gauche de '.EofChar' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	67	
Erreur	55	error C2228: la partie gauche de '.EvtChar' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	68	
Erreur	56	error C2065: 'a_overlap' : identificateur non déclaré	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	71	
Erreur	57	error C2228: la partie gauche de '.hEvent' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	71	
Erreur	58	error C3861: 'CreateEvent' : identificateur introuvable	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	71	
Erreur	59	error C2228: la partie gauche de '.Internal' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	72	
Erreur	60	error C2228: la partie gauche de '.InternalHigh' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	73	
Erreur	61	error C2228: la partie gauche de '.Offset' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	74	
Erreur	62	error C2228: la partie gauche de '.OffsetHigh' doit avoir un class/struct/union	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	75	
Erreur	63	error C2065: 'a_open' : identificateur non déclaré	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	78	
Erreur	65	error C2653: 'QWinSerialPort' : n'est pas un nom de classe ni d'espace de noms	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	85	
Erreur	66	fatal error C1903: impossible de récupérer à partir des erreurs précédentes ; arrêt de la compilation	c:\documents and settings\administrateur\bureau\rs232_pour_qt\rs232 pour qt\qwinserialport.cpp	85	



Cordialement,
bypbyop

#14 Black Templar

Black Templar

    Membre

  • Membres
  • PipPipPipPipPip
  • 1 430 messages
  • Gender:Male
  • Location:Lille

Posté 14 novembre 2011 - 12:15

Bonsoir Black Templar,

dslé tout à l heure mon message etait pour toi ;-)


J'ai bien compris. C'est pour ça que je t'ai rediriger vers un tutoriel pour apprendre les bases de la programmation en C++.
Sans ça, je ne pense pas que tu sois du niveau pour modifier ma bibliothèque (qui, je l'ai déjà dit plusieurs fois, n'est pas utilisable dans l'état).

Je te remet donc le lien : http://www.siteduzero.com/tutoriel-3-11406-programmez-avec-le-langage-c.html


++
Black Templar

Mon site internet : http://ferdinandpiette.com/





0 utilisateur(s) li(sen)t ce sujet

0 members, 0 guests, 0 anonymous users