31 réponses à ce sujet

[Kurnyx]

Bonjour,



Je suis tout nouveau sur le site, (voir ici ma présentation) et j'aurais besoin pour un petit projet de savoir :

Comment peut-on faire pour commander l'allumage/arrêt d'une lampe si celle-ci doit-être connectée à un PC (USB...etc) ? Que dois-je faire pour réguler l'alimentation à partir du PC ?



Merci d'avance à ceux qui me répondront ;)

Kurnyx



PS: La tension aux bornes d'un USB étant d'environ 5V --> c'est suffisant.

[miky-mike]

Alors tu peux piloté une lampe via le port série, parallèle, usb.
Pour le port usb, il faudra passé pas une interface avec pic donc plus gros.

Le plus facile est d'utiliser le port parallèle avec une petite interface avec 1 relais (1lampe) , les tuto en plus la dessus ne manque pas sur le net comme par exemple : http://www.sonelec-musique.com/electronique_realisations_interfaces_lpt_001.html

[Kurnyx]

Merci pour la réponse rapide ;)



J'ai bien regardé certains liens trouvés sur le Net, je situe à peu près le schéma de montage.

Mais comment faire pour envoyer un signal à une certaine borne ?

D'ailleurs est-ce un signal numérique ou analogique ?



Simplement pour allumer/éteindre une lampe !

[miky-mike]

Quel port vas tu utilisé ?
Dans quel langage vas tu programmer ?
Quel système d'exploitation ?

Cela varie fortement suivant le donnée du dessus.

[Kurnyx]

Alors pour le port je pense que je vais utiliser le port parrallèle (LPT1) qui me semble assez facile d'accès ;) (j'ai le choix entre une bonne dizaine de bornes).

Le langage de prog ? N'importe lequel entre C, Basic, Python, quoique le C semble plus approprié.

Le montage se fera sur Windows, car je ne possède ni ne connais pas les autres plate-formes.

J'espère avoir tout dit...je n'ai plus besoin que de la solution ! :|
Merci

[miky-mike]

Je n'ai jamais contrôlé ce port, donc je je sais pas tellement t'en dire plus.

Par contre c'est très facile a ce que j'ai déjà entendu, il y a plein de tuto et de source sur le net.

Utilise la DLL inpout32.dll pour géré le port .

[Shuzaku]

J'ai des fonctions en C pour bosser avec le port série si tu veux, mais rien avec le port parallèle, ça doit pouvoir se trouver sur internet comme l'a précisé miky-mike.

[Kurnyx]

Ah oui, je veux bien des fonctions pour le port série !
Je jujerais par la suite ce qui est le plus faisable, peux-tu m'indiquer ce que tu sais à ce sujet Shuzaku ?

J'ai effectivement regardé sur Internet, il y a des montages, mais rien pour lancer l'ordre depuis le PC ! :o

[robocop]

C'est plus facile par le port parralèle, tu changes la sortie directement.
Ex sous linux : http://mykey57.free.fr/?rub=documents&page=cours&mat=informatique&cours=linux_port_parallele

(testé et approuvé).

[Shuzaku]

Voilà le code, testé et approuvé aussi, tu peux faire tes test à l'aide de deux Pc reliés par un câble série et en lançant le logiciel "hyperterminal" sur chacun (Démarrer, accessoires, communications)

//-------------------------------------------------------------------------------
// 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();

// 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

//------------------------------------------------------------------------------
// 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]


//ouverture port
g_ErrCom=OuvreCom(PORT1,V9600,BITS_8,PARITE_PAIRE,BIT_DE_STOP_1);
//émission d'un octet
g_ErrCom=EmissionCom(&moteur_gauche,1);
//autre exemple d'emission
g_ErrCom=EmissionCom("UneTrame",sizeof("UneTrame"));[/code]


[Kurnyx]

Merci beaucoup pour les liens et fonctions ;)

J'aimerais tout d'abord savoir quelle est la tension aux bornes du port parallèle (et aux quelles bornes ?) ainsi qu'aux bornes du port série...

Ensuite quelle type de phrase en code dois-je executer pour interrompre cette alimentation ?

Je sens que j'approche du but, merci de m'aider :)
Kurnyx

PS: Je ne comprends pas apparemment pourquoi personne n'a déjà fait une manip de base de mon style ?

[robocop]

Il me semble que c'est 3.3 volt (à vérifier) sur le port parallèle.

[Shuzaku]

0-5V (TTL) en série

[Kurnyx]

ok :o
Et je peux brancher mon dipôle sur quelles broches ? (par ex. la 1ere celle d'en haut à droite et... ?)

C'est limite 3,3 V pour une bonne lampe quand même... Je pense que pour augmenter je rajouterais une alim externe, et c'est le PC (par l'intermédiaire de ces broches +/-) qui fera fonctionner un relais pour activer le tout... ;)

[robocop]

Evidammant, il faut s'en servir comme commande, pas comme alim :D !

[Kurnyx]

Oui :D
Mais je réitère ma question :

[quote"Kurnyx"]
Et je peux brancher mon dipôle sur quelles broches ? (par ex. la 1ere celle d'en haut à droite et... ?)
[/quote]
Merci

[Tixlegeek]

salut

j'ai écrit un tuto que je pense accessible à tous

--> http://membres.lycos.fr/trans04/4_0/thread.php?page=lire_articles&id=24

fais pas gaffe à la pub, c'ets mon vieux site, elles ont repris leur droits, je le réécrit en ce momment sur le club e-generation.sup.fr :)

++

[Kurnyx]

Merci beaucoup !! Je me suis plongé dedans, j'ai commencé à reprogrammer en QBasic...
C'est presque enfantin ! J'attends de récupérer des câbles parallèles pour pouvoir tester, je vais pouvoir réaliser tous mes rêves (ventilo réglable, modules externe...) :D :tare:

Pourra-tu aussi faire la partie "lecture" (A1) ?

A bientôt pour d'autres nouvelles,
Kurnyx

PS: Dommage que ces prises coûtent au moins 10€... :|

[Kurnyx]

Rebonjour à tous,

Je me permet de vous demander où je pourrais trouver des prises et câbles parallèles, car j'en ai bien besoin ! ;) Je voudrais les moins chers possibles, à moins que vous n'en ayez dont vous ne vous servez pas... :|

Merci d'avance,
Kurnyx

PS : encore merci Tix pour le tuto, il est génial (et unique à ce que j'ai vu :heu: )

[Kurnyx]

C'est bon ! :o

J'ai maintenant un port parallèle ;) J'ai dénudé les fils, trouvé à quoi correspondait chacun, et j'aimerais maintenant réaliser le montage du site Tr@nsisterix. J'ai le matériel, mais je ne sais pas où connecter le - de mes lampes ? Où se trouve la masse ? Je connecte le - sur une sortie logique, le bord en métal du port ?



Je sais que c'est une question un peu "débutante" mais ne pratiquant pas souvent, je ne veux pas tout griller !

Merci d'avance :)