Salut à tous,

Je suis actuellement porteur d'un projet avec des amis à moi (désolé mais je peux pas apporter plus de détails), et nous avons besoin de créer un petit boitier qui, une fois connecté en usb, pourrait exécuter un batch sur l'ordinateur quand on appuie sur un bouton. Ce fichier batch est relativement basique, et ne requiert pas d'être exécuter en administrateur. J’imagine qu'il faudra que je donne tous les droits possibles et imaginables à ce "boitier", mais là n'est pas le problème. Je n'ai aucune idée de comment construire ce boitier ! C'est vrai, on est habitué à ce que ça soit l'ordinateur qui envoie des infos au projet, mais pas l'inverse (enfin pas pour moi en tout cas) !

J'ai accès à du matériel électronique, et notamment à des cartes arduino avec lesquelles je commence à être familier. J'espère que mon projet n'est pas irréalisable, ça mettrait en l'air beaucoup d'heures de travail...

Merci beaucoup d'avance pour votre aide !

P.S :  C'est pas obligatoire, mais si le boitier pouvait aussi simuler un clique de souris (peu importe ou sur l'écran) ça serait génial

-
Edité par Anonyme 6 novembre 2014 à 23:04:56

Je te rassure, ce que tu veux faire est tout à fait possible

Après, il existe différentes méthodes plus ou moins propre et plus ou moins complexe.

 La plus propre mais aussi la plus complexe serait de développer un protocole de communication USB spécifique ainsi que le driver qui va avec.

Ainsi, lorsque tu brancherais la carte, Windows la reconnaitrait automatiquement à l'aide du driver en affichant le petit message : "Nouveau périphérique détecté : carte de développement NeedCoffee".

Vu que c'est ton protocole et ton driver, tu peux envoyer/recevoir n'importe quoi (c'est toi qui choisi) et c'est le driver qui se charge d'exécuter le ordres reçus.

 La solution la plus simple mais aussi la moins propre serait d'utiliser ce que tu as sous la main pour arriver à tes fins.

Tu pourrais donc te servir de la communication Serial de l'arduino pour faire de la communication.

Lorsque tu brancheras l'arduino au PC, tu auras un message du genre : "Nouveau périphérique détecté :COM PORT #5" (beaucoup moins classe) qui signifie que le PC a bien détecté une liaison série.

Sur l'arduino, il te suffira d'envoyer des ordres avec Serial :

Serial.println("EXEC: script.bat");
Serial.println("MOUSE: 50,47");

Et bien sur, il te faudra développer un programme qui tourne en tache de fond sur le PC.

Ce programme aura pour mission de détecter l'arrivé d'un nouveau port COM, l'ouvrir et analyser les données reçues.

Si il reçoit une ligne qui commence par EXEX:, il sait qu'il doit lancer un script BASH.

Salut,

Merci beaucoup pour ta réponse !
En effet la première proposition est beaucoup plus adaptée, mais aussi beaucoup plus complexe... Le message affiché au branchement m’importe peu, c'est juste le fait de devoir créer un programme qui tourne en tache de fond qui me pose problème. Je pense que je vais malgré tout utiliser l'arduino parce que, à vrai dire, je n'ai aucune idée de comment fabriquer une telle carte (à moins qu'il existe une solution simple pour la réaliser évidemment).

Du coup il faut que je me lance dans la réalisation du programme. Le problème c'est que je n'ai jamais créé un programme qui "a pour mission de détecter l'arrivé d'un nouveau port COM, l'ouvrir et analyser les données reçues". Pourrais tu me donner une piste pour commencer mes recherches ? Sur le langage à utiliser ?

Merci d'avance

-
Edité par Anonyme 7 novembre 2014 à 10:06:23

Personnellement, je te conseillerais bien C++ et Qt mais il existe surement d'autres méthodes.

Si tu utilises Qt 4.x, il te faudra aussi inclure la lib QextSerialPort dans ton projet : http://code.google.com/p/qextserialport/

Si tu utilises Qt 5.x, tu n'as rien à faire, QextSerialPort est déjà présente

Pour détecter l'arrivé d'un nouveau port, le plus simple serait de faire une sorte de rafraichissement des ports disponible de temps en temps.

Par exemple, tu te sert d'un QTimer pour déclencher un slot toutes les 50ms.

Dans ce slot, tu listes tous les ports disponible à l'aide de QSerialPortInfo::availablePorts() et tu compares cette liste avec la liste du précédant appel.

Si tu vois qu'il y a un élément de plus, c'est donc qu'un nouveau port a été ajouté au PC

Après, il te faudra utiliser la classe QSerialPort pour ouvrir ce port et l'écouter.

Concernant Qt, il y a un chapitre entier consacré à cette lib dans le cours C++.

Tu trouveras aussi pleins d'exemple sur le net (google est ton amis) ainsi que sur la doc de Qt.

Pour ce qui est de QextSerialPort, il y a aussi pleins d'exemple sur le net.

Salut,

Bon j'ai commencé mon programme QT. J'ai mis en place le QTimer avec les slots de 50ms. Tout fonctionne pour le mieux (pour l'instant en tout cas). J'ai alors voulu me lancer dans le listage des ports comme tu le conseil, mais je n'arrive pas à trouver comment faire en sorte que le programme reconnaisse la carte arduino dans la liste et interprète les ordres... En effet le boitier ne sera pas la seule chose que je brancherait en USB sur mon pc, il faut donc que le programme analyse le port COM pour savoir si il s'agit de la carte arduino, ou d'un autre matériel quelconque, puis si il s'agit de la arduino, interpréter les ordres. J'ai fais pas mal de recherches, mais les seuls réponses que j'ai trouvée n'étaient pas compatibles avec QT et C++.

Si ça peut aider, voilà mon code actuel :

En-têtes :

maClasse.h

#ifndef MACLASSE_H
#define MACLASSE_H

#include<QCoreApplication>
#include<QTimer>
#include<QObject>


class maClasse:QObject
{
Q_OBJECT
public:
maClasse();
public slots:
void fonction();
private:
QTimer*timer;
};

#endif // MACLASSE_H

Sources :

maClasse.cpp

#include"maclasse.h"
#include<iostream>


maClasse::maClasse()
{
timer=new QTimer;
connect(timer,SIGNAL(timeout()),this,SLOT(fonction()));
timer->start(50);
}


void maClasse::fonction()
{
    // Ici analyse des ports COM etc...
}

main.cpp

#include<QCoreApplication>
#include"maClasse.h"


int main(int argc,char*argv[])
{
QCoreApplication a(argc,argv);
maClasse monTimer;


return a.exec();
}

Merci beaucoup d'avance !

-
Edité par Anonyme 8 novembre 2014 à 16:31:12

Tu as peut-être plusieurs périphériques mais tous le se comportent pas en temps que port COM.

Du coup, tout devrait bien se passer.

Comme je te l'ai dis, tu dois te baser sur QList<QSerialPortInfo> QSerialPortInfo::availablePorts() [static] pour avoir la liste des ports disponible.

Ton code devrait donc être :

 
class MaClasse : public QObject {
	
	Q_OBJECT
	
	public:
		MaClasse();
		QStringList getAllPortNames();

	public slots:
		void checkPorts();
	
	private:
		QStringList m_oldPortNames;
		QTimer *m_timer;
	
};


MaClasse::MaClasse() {
	
	// Au lancement de l'application, on complète la liste m_oldPortNames
	// A ce moment là, l'arduino ne doit donc pas être banché (ou il ne sera pas détecté)
	m_oldPortNames = getAllPortNames();
	
	m_timer = new QTimer(this);
	connect(m_timer, SIGNAL(timeout()), this, SLOT(checkPorts()));
	m_timer->start(50);
	
}


QStringList MaClasse::getAllPortNames() {

	QStringList ports;
	
	foreach ( QSerialPortInfo portInfo, QSerialPortInfo::availablePorts() ) {
		ports.append(portInfo.portName());
	}
	
	return ports;
	
}


void MaClasse::checkPorts() {
    
	// On réccupère tous les ports détectés
	QStringList newPortNames;
	
	// On vérifie si un nouveau port est apparu dans la liste
	foreach ( QString port, newPortNames ) {
		if ( !m_oldPortNames.contains(port) ) {
			
			// Ce port est nouveau, il faut donc l'ouvrir !
			
		}
	}
	
	// On met à jour la liste m_oldPortNames
	m_oldPortNames = newPortNames;
	
}