Que dire à part ... bloqué ^^

Je suis pas modo mais tant pis !

Un compilateur il transforme pas le C en assembleur ? <.<

oui voilà zigbee :p (bah là c'était pour un projet de robot téléopéré)

Je sais pas trop, il faut chercher sur internet mais je crois que ceux que j'ai eu l'occasion de maniper valait tout de même quelques centaines d'euros :x (mais ils avaient une porté de 200 mètre aussi et utilisait les ondes xbee un truc comme ça)

Comment ça c'est pas adapté à une télécommande :p

Inutile de ré-inventer l'eau chaude tout les jours :x

Certes on apprend moins en utilisant des modules tout prêt mais pour un débutant qui à besoin d'émerveillement pour trouver le courage de se lancer lui même dans les moindre détailles de l'électronique je vois pas le souci ! Que chacun trouve sa voie :p

étant donné que, contrairement à la programmation, la robotique n'est pas gratuite :p ).

A notre grand malheur ...



Je serais toi, je commencerais par effectuer une première étape que je vais te décrire, qui ne demande pas d'électronique ni rien de tout ça, juste 2 PC reliés par câble série seraient nécessaire !



Tu chope un joystick, un langage de programmation que tu connais bien qui sait bosser avec les joysticks (le C et la SDL à tout hasard ...), aller en cadeau je te met à la fin de ce message des fonctions qui permettent d'utiliser le port série parce que ça peut être relou à trouver sur le web.



Sur Windows tu as un truc très sympa qui s'appelle "Hyper Terminal" dans démarrer->tout les programmes->accessoires->communication. Ce fameux hyperterminal permet de travailler avec le port série lui aussi.



Sur le premier PC, tu créer un programme qui est capable de lire le joystick et les boutons que tu veux.

Ce programme va devoir renvoyer l'info du joystick sur le port série avec un quelconque octet (nombre) que tu choisi, par exemple tu renvoi un 1 sur le port série si tu appuie sur le bouton 1, un 2 si c'est le deuxième bouton etc.



Sur le second PC, tu va ouvrir ce fameux hyper terminal, tu donnes un nom bidon à ta connexion hyper terminal quand il te le demande, tu fais ok, tu choisies "Se connecter en utilisant COM3", ensuite tu mets 9600 bits/seconde, 8 bits de données, partié paire, bit d'arrêt 1, contrôle de flux matériel. Voilà, ton hyperterminal est réglé et affichera maintenant tout ce qu'on lui enverra par le port COM.



Tu relie bien sûr les deux PC avec un câble série qui convient.



Maintenant, le but est que lorsque tu appuie sur un bouton de ton joystick, tu recoive bien le nombre du bouton sur le second PC. Si déjà tu parvient à ce résultat, c'est que ta bien bossé !



Des exemples d'utilisation des fonctions :




g_ErrCom=OuvreCom(PORT1,V9600,BITS_8,PARITE_PAIRE,BIT_DE_STOP_1);



//émission vers port

g_ErrCom=EmissionCom(&moteur_gauche,1);[/code]




// FONCTION : OuvreCom

//------------------------------------------------------------------------------

// DESCRIPTION :

// Initialise et ouvre un port série

//

//------------------------------------------------------------------------------

// PARAMETRES :

// - strPort Nom du port "COM1", "COM2"

// - BaudRate Vitesse

// - BitsSize Taille de l'info

// - Parity Parité

// - StopBits Nombre de bits de stop

//

// RETOUR :Code d'erreur

//------------------------------------------------------------------------------

e_ErrCom OuvreCom(char *strPort,long BaudRate,int BitsSize,int Parity,int StopBits)

{

g_ErrCom = e_ErrCom_None;



// On ouvre le port série

g_hCom = CreateFile(strPort,GENERIC_READ | GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING,NULL);



if(g_hCom == INVALID_HANDLE_VALUE)

{

// Echec

g_ErrCom=e_ErrCom_Creation;

}

else

{

// On vide les buffers

PurgeComm(g_hCom,PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);



// On paramètre le port série

g_DCB.DCBlength = sizeof(DCB);

//Configuration actuelle

GetCommState(g_hCom, &g_DCB);

//Modification du DCB

g_DCB.BaudRate=BaudRate;

g_DCB.ByteSize=BitsSize;

g_DCB.Parity=Parity;

g_DCB.StopBits=StopBits;

g_DCB.fDtrControl=DTR_CONTROL_DISABLE;

//Configuration de la liaison serie

SetCommState(g_hCom,&g_DCB);

}

return g_ErrCom;

}





//----------------------------------------------------------------------------

// FONCTION : EmissionCom

//----------------------------------------------------------------------------

// DESCRIPTION :

// Emission d'octets sur la liaison série

//

//----------------------------------------------------------------------------

// PARAMETRES :

// -lpBuf Pointeur sur les octets a emettre

// -nCount Nombre d'octet a emettre

//

//----------------------------------------------------------------------------

// RETOUR :Code d'erreur

//----------------------------------------------------------------------------

e_ErrCom EmissionCom(const void* lpBuf,unsigned int nCount)

{



DWORD NumBytes=0;



if(g_hCom!=NULL)

{

// On pari sur pas d'erreur

g_ErrCom=e_ErrCom_None;



//Emission du buffer

if(WriteFile(g_hCom,lpBuf,nCount,&NumBytes,NULL)==0)

{

g_ErrCom=e_ErrCom_Emission;

}

}

else

//Le port n'a pas été ouvert

g_ErrCom=e_ErrCom_Creation;



return g_ErrCom;



}



//---------------------------------------------------------------------------

// FONCTION : ReceptionCom

//---------------------------------------------------------------------------

// DESCRIPTION :

// Reception de caractères sur la liaison série

//

//---------------------------------------------------------------------------

// PARAMETRES :

// -lpBuf Pointeur sur le buffer de caractère a lire

// -nCountMax Nombre maxi de caractère a lire

// -pCountRead Pointeur sur le nombre de caractères lus

//---------------------------------------------------------------------------

// RETOUR :Code d'erreur

//---------------------------------------------------------------------------

e_ErrCom ReceptionCom(void *lpBuf,unsigned int nCountMax, unsigned int* pCountRead)

{

COMSTAT Stat;

DWORD Errors;

unsigned int nCarALire;

unsigned long NCarLus=0;



if(g_hCom!=NULL)

{

//on pari sur pas d'erreur

g_ErrCom=e_ErrCom_None;



//Pour éviter de gérer un time out

Sleep(500);



//Pour connaitre le nombre d'octets dans le buffer d'entrée

ClearCommError(g_hCom,&Errors,&Stat);

nCarALire=Stat.cbInQue;



//On effectue la lecture si il y a des caractères présents

if( (nCarALire>0)&&(nCarALire<=nCountMax) )

{

if(ReadFile(g_hCom,lpBuf,nCarALire,&NCarLus,NULL)==0)

{

g_ErrCom=e_ErrCom_Reception;

}



}

*pCountRead=NCarLus;

}

else

//Le port n a pas été ouvert

g_ErrCom=e_ErrCom_Creation;



//Compte rendu de l'exécution

return g_ErrCom;



}



//-----------------------------------------------------------------------

// FONCTION : FermeCom

//-----------------------------------------------------------------------

// DESCRIPTION :

// Ferme le port série préalablement ouvert avec OuvreCom

//

//-----------------------------------------------------------------------

// PARAMETRES :

// Néant

//-----------------------------------------------------------------------

// RETOUR :Néant

//-----------------------------------------------------------------------

void FermeCom()

{

if(g_hCom!=NULL)

{

CloseHandle(g_hCom);

}

}[/code]



Code d'en tête, tu as des truc inutile à enlever là dedans, je le mets juste pour t'aider ...


//------------------------------------------------------------------------------

#include

#include

#include

#include

#include

#include

#include

#include

#include



// CONSTANTES

//-------------------------------------------------------------------------------

// Définition du code d'erreurs

typedef enum

{

e_ErrCom_None, // Pas d'erreur

e_ErrCom_Creation, // Erreur lors de la création du flux

e_ErrCom_Utilise, // Le port com est déjà utilisé

e_ErrCom_Inexistant, // Le port com n'existe pas

e_ErrCom_Timeout, // Timeout lors d'une émission-réception

e_ErrCom_Emission, // Erreur lors de l'émission

e_ErrCom_Reception, // Erreur lors de la réception

e_ErrCom_Definition_Trame, // Erreur de définition de la trame

e_ErrCom_Nack, // Demande non prise en coompte

e_ErrCom_Checksum // Erreur de checksum

} e_ErrCom;



// Nom du port série

#define PORT1 "COM1"

#define PORT2 "COM2"



// Définition des vitesses de communication

#define V1200 1200

#define V2400 2400

#define V4800 4800

#define V9600 9600



// Définition du nombre de bits

#define BITS_7 7

#define BITS_8 8



// Définition du nombre de bits de stop

#define BIT_DE_STOP_1 1

#define BIT_DE_STOP_2 2



// Définition de la parité

#define PAS_DE_PARITE 'N'

#define PARITE_IMPAIRE 'O'

#define PARITE_PAIRE 'E'



// Codes de retour génériques

#define OK 1

#define KO 0



// Longueur max réservée pour une trame

#define LG_TRAME 100



// PROTOTYPES

//----------------------------------------------------------------------------

e_ErrCom OuvreCom(char *strPort,long BaudRate,int BitsSize,int Parity,int StopBits);

e_ErrCom EmissionCom(const void *lpBuf, unsigned int nCount);

e_ErrCom ReceptionCom(void *lpBuf, unsigned int nCountMax, unsigned int *pCountRead);

void FermeCom();

void pause();

void image_position(int position, SDL_Surface *ecran, SDL_Surface *imageDePosition);



// VARIABLES GLOBALES

//-----------------------------------------------------------------------------

DCB g_DCB; // structure dcb du port

e_ErrCom g_ErrCom= e_ErrCom_None; // Variable des erreurs de com

HANDLE g_hCom = 0; // handle de la com[/code]



BON COURAGE ET BONNE CHANCE !



Après, l'info primaire est sortie de ton PC, il ne reste plus qu'à la faire voyager dans des ondes ! :p