[RESOLU] SerialPort et WiFi

[Dumli]

Salut tout le monde,

Je possède une carte Arduino UNO (http://arduino.cc/en/Main/ArduinoBoardUno) avec un module WiFi (http://www.robotshop.com/cupperhead-wif ... duino.html) et je voudrais savoir s'il est possible de lire/envoyer des informations à la carte via le port COM ? J'ai trouvé la librairie SerialPort dans PureBasic mais je voudrais savoir si elle est bien adaptée à ma carte ? Le but serait d'envoyer des appuis de touches du clavier directement à la carte par WiFi. Je voudrais donc dans un premier temps le faire par USB mais au final il faudrait que je parvienne à le faire par WiFi. Là arrive alors la seconde question, est-ce que la méthode du SerialPort sera valable pour envoyer des infos en WiFi ?

Merci de m'éclairer sur le sujet

Cordialement,

[MetalOS]

Il te faudra un shield spécifique je pense. Mais pour la programmation il faut utiliser l'IDE arduino.

[G-Rom]

en théorie oui, de mémoire l'Arduino à un convertisseur usb<>série.
si cela ne marche pas ( je testerais aussi ) , tu peut toujours passer par un max232 pour une communication série.
si tu veut une carte beaucoup plus performante que l'arduino : http://fr.wikipedia.org/wiki/Raspberry_Pi

[Dumli]

Ah priori donc, je pourrais bien faire un petit programme qui envoie les données directement à la Arduino. Cepedant comment faire pour le WiFi après ? Ca sera radicalement différent ?

[MetalOS]

Je ne pense pas que l'arduino arrive à lire du code purebasic.

[mad]

Bonjour à tous,

Je passais par là, et j'ai croisé ce post...


Pour ton module Arduino, c'est tout à fait possible.


Pour mon propre besoin de télécommander un téléscope, j'ai créer moi même mon système sur une carte, avec un module beaucoup plus basic.

J'ai donc, par rapport au datasheet du constructeur, encaspuler les bits, pour dialoguer avec l'interface.

En fait, bien sûr, arduino ne comprend pas le language de purebasic, mais regarde la méthode de communication. Par exemple le port usb, que j'avais acheté était de marque FTDI. Il est bien connu des électroniciens, car il embarque automatiquement, une puce pour la communication USB.

Pour mon cas, c'est de l'encapsulation de mots de 8bits.

Pour ton cas, cela dépend du module que tu as acheté. Mais c'est tout à fait possible.

Pour ton wifi, il absolument, soit trouver un librairie (en C en rêgle général), afin de d'encapsuler automatiquement ces fameux bit... Car je pense que ce n'est plus sur 8bit, mais beaucoup plus...

[mad]

Tiens, pour exemple je t'ai filé l'encodeur décodeur de bits que j'ai fait pour ma puce.
La puce qui est contrôlé est une ULN2003a. La puce que me fait communication et le transports des bits
dans le Bus que j'ai placé entre le COM et l'UNL2003a, est codé sur 8Bits... Logique il y a 8 entrées.

Code : Tout sélectionner

;-----------------------------------------------------------------------------------
;
; Modèle PUREBASIC : 2.6
;
;-----------------------------------------------------------------------------------
;
;-
;
; Titre du programme  : 
;- Auteur              :  MAD
;- Version             :  0
;- Date de création    :
;- Date de modification :
;
; Commentaires et remarques :
; ---------------------------
;
;
;
;
;
;-
;-----------------------------------------------------------------------------------

;-----------------------------------------------------------------------------------
;- Comportement et directives de compilation (pour le compilateur)
;-----------------------------------------------------------------------------------

EnableExplicit
;EnableASM

;-----------------------------------------------------------------------------------
;- Définition des Structures
;-----------------------------------------------------------------------------------

Structure ConfigReveilleActionPort ; Conçu pour la fonction qui programme un bit du FIFO sur un temp donnée
	ID_PeripheriqueUSB.i
	Port.a
	EtatPort.b
	Duree.i ; Exprimer en millisecondes
EndStructure

;-----------------------------------------------------------------------------------
;- Définition des constantes
;-----------------------------------------------------------------------------------

; code erreur


Enumeration 
	#FT_OK
	#FT_INVALID_HANDLE
	#FT_DEVICE_NOT_FOUND
	#FT_DEVICE_NOT_OPENED
	#FT_IO_ERROR
	#FT_INSUFFICIENT_RESOURCES
	#FT_INVALID_PARAMETER
	#FT_INVALID_BAUD_RATE
	#FT_DEVICE_NOT_OPENED_FOR_ERASE
	#FT_DEVICE_NOT_OPENED_FOR_WRITE
	#FT_FAILED_TO_WRITE_DEVICE
	#FT_EEPROM_READ_FAILED
	#FT_EEPROM_WRITE_FAILED
	#FT_EEPROM_ERASE_FAILED
	#FT_EEPROM_NOT_PRESENT
	#FT_EEPROM_NOT_PROGRAMMED
	#FT_INVALID_ARGS
	#FT_NOT_SUPPORTED
	#FT_OTHER_ERROR
	#FT_DEVICE_LIST_NOT_READY
EndEnumeration

Enumeration
	#FT_DEVICE_BM
	#FT_DEVICE_AM
	#FT_DEVICE_100AX
	#FT_DEVICE_UNKNOWN
	#FT_DEVICE_2232C
	#FT_DEVICE_232R
	#FT_DEVICE_2232H
	#FT_DEVICE_4232H
	#FT_DEVICE_232H
EndEnumeration



;Constantes pour la fonction FT_SetBitMode
#FT_BITMODE_RESET	= $00
#FT_BITMODE_ASYNC_BITBANG = $01
#FT_BITMODE_MPSSE	= $02
#FT_BITMODE_SYNC_BITBANG = $04
#FT_BITMODE_MCU_HOST = $08
#FT_BITMODE_FAST_SERIAL = $10
#FT_BITMODE_CBUS_BITBANG = $20
#FT_BITMODE_SYNC_FIFO = $40




;
; Bit d'arrêt (Stop Bits)
;

#FT_STOP_BITS_1 = "0"
#FT_STOP_BITS_1_5 = "1"
#FT_STOP_BITS_2 = "2"

;
; Parité (Parity)
;

#FT_PARITY_NONE = "0"
#FT_PARITY_ODD = "1"
#FT_PARITY_EVEN = "2"
#FT_PARITY_MARK = "3"
#FT_PARITY_SPACE = "4"

;
; Contrôle de flux (Flow Control)
;

#FT_FLOW_NONE = $0000
#FT_FLOW_RTS_CTS = $0100
#FT_FLOW_DTR_DSR = $0200
#FT_FLOW_XON_XOFF = $0400


;
; Encode des bits de la puce FIFO
;
;Représente les pins FIFO codé sur 8 bits.

#FIFO_D0 = %00000001
#FIFO_D1 = %00000010
#FIFO_D2 = %00000100
#FIFO_D3 = %00001000
#FIFO_D4 = %00010000
#FIFO_D5 = %00100000
#FIFO_D6 = %01000000
#FIFO_D7 = %10000000
#FIFO_FULL = #FIFO_D0|#FIFO_D1|#FIFO_D2|#FIFO_D3|#FIFO_D4|#FIFO_D5|#FIFO_D6|#FIFO_D7

;-----------------------------------------------------------------------------------
;- Définition des prototypes
;-----------------------------------------------------------------------------------

Prototype.b FT_Open (NumUSB.i,*ID_USB)
Prototype.b FT_Close (ID_USB)
Prototype.b FT_Read (ID_USB,*RecuperationBiT,NombreBitsARecuperer,*RetourNBBit)
Prototype.b FT_Write (ID_USB,*CodeBinATransmettre,TailleBuffer_CodeBinATransmettre,*RetourNBBitEnvoye)
Prototype.b FT_SetBitMode (ID_USB, BitModeMask, ValeurUcMode)

;-----------------------------------------------------------------------------------
;- Définition des variables
;-----------------------------------------------------------------------------------

Global MUT_InstructionFIFO.i

;-----------------------------------------------------------------------------------
;- Ajout de modules
;-----------------------------------------------------------------------------------
;Import ".\FTDI_whql\static\i386\FTD2XX.obj"
	
;EndImport

;-----------------------------------------------------------------------------------
;- Ajout de données (DATASECTION)
;-----------------------------------------------------------------------------------
DataSection

EndDataSection
;-----------------------------------------------------------------------------------
;- Déclaration des procédures
;-----------------------------------------------------------------------------------
Declare.b ReveilleActionPort(*Config.ConfigReveilleActionPort)
 

;-----------------------------------------------------------------------------------
;- Définition des Objets
;-----------------------------------------------------------------------------------


;-----------------------------------------------------------------------------------
;- Appel de pile / Initialisation de module (initNetwork())
;-----------------------------------------------------------------------------------


;-----------------------------------------------------------------------------------
;- Execution du code
;-----------------------------------------------------------------------------------
MUT_InstructionFIFO = CreateMutex()


;-----------------------------------------------------------------------------------
;- Définition des Fonctions
;-----------------------------------------------------------------------------------
Procedure.i ChargeLibrairieFTDI(EmplacementLibrairie$="ftd2xx.dll")	
	Define ID_OuvertureLibrairieFTD2XX.i
	;Shared ID_OuvertureLibrairieFTD2XX.i
	
	Global FT_Open.FT_Open, FT_Close.FT_Close, FT_Write.FT_Write, FT_Read.FT_Read, FT_SetBitMode.FT_SetBitMode
	
	EmplacementLibrairie$ = madlib_CodeNDF(EmplacementLibrairie$)
	ID_OuvertureLibrairieFTD2XX = OpenLibrary(#PB_Any,EmplacementLibrairie$)		
	
	;Récupération des différentes Fonctions listé en prototype.
	FT_Open = GetFunction(ID_OuvertureLibrairieFTD2XX,"FT_Open")
	FT_Close = GetFunction(ID_OuvertureLibrairieFTD2XX,"FT_Close")
	FT_Write = GetFunction(ID_OuvertureLibrairieFTD2XX,"FT_Write")
	FT_Read = GetFunction(ID_OuvertureLibrairieFTD2XX,"FT_Read")
	FT_SetBitMode = GetFunction(ID_OuvertureLibrairieFTD2XX,"FT_SetBitMode")
	
	ProcedureReturn ID_OuvertureLibrairieFTD2XX
EndProcedure

Procedure.a EncodeBinFIFO(Port.a,EtatPort=#PB_Ignore)
	
	Static CodeBinActuel.a
	
	;Encode des bits avec les bits déja existants
	;EncodageBin = RecupereCodeBinaire(ID_PeripheriqueUSB)
	Debug "EncodeBinFIFO : Avant encodage => "+RSet(Bin(CodeBinActuel),8,"0")
	Debug "EncodeBinFIFO : Port demandé   => "+RSet(Bin(Port),8,"0")	
	;Si l'état du port est égal a False alors sous traction binaire du port	
	If EtatPort = #True		
		CodeBinActuel | Port
	ElseIf EtatPort = #False
		CodeBinActuel & ~Port
	ElseIf EtatPort = #PB_Ignore
		CodeBinActuel = Port
	EndIf		
	Debug "EncodeBinFIFO : Après encodage => "+RSet(Bin(CodeBinActuel),8,"0")
	Debug "                                   -------------------------------"
	ProcedureReturn CodeBinActuel
EndProcedure

Procedure.b ConfigureModeBitBang(ID_USB,PortFIFO.b=#FIFO_FULL,Mode=#FT_BITMODE_ASYNC_BITBANG)
	Global MUT_InstructionFIFO
	
	LockMutex(MUT_InstructionFIFO)
		FT_SetBitMode(ID_USB,PortFIFO,Mode)
		;CallFunction(1,"FT_SetBitMode",ID_USB,$FF,Mode)
	UnlockMutex(MUT_InstructionFIFO)
EndProcedure

Procedure.a RecupereCodeBinaire(ID_PeripheriqueUSB,NombreBitARecuperer=8)
	;Shared ID_OuvertureLibrairieFTD2XX
	Protected RetourNBBits.a, RecuperationBiT.a, REF.a
	Global MUT_InstructionFIFO
	
	LockMutex(MUT_InstructionFIFO)
		;CallFunction(ID_OuvertureLibrairieFTD2XX,"FT_Read",ID_PeripheriqueUSB,@RecuperationBiT,NombreBitsARecuperer,@RetourNBBits)
		FT_Read(ID_PeripheriqueUSB,@RecuperationBiT,NombreBitARecuperer,@RetourNBBits)
		REF = RecuperationBiT
	UnlockMutex(MUT_InstructionFIFO)
	ProcedureReturn REF	
EndProcedure

Procedure.a EnvoyeCodeBinaire(ID_PeripheriqueUSB,CodeATransmettre.a) ; Sert juste a envoyer le code binaire au fifo via usb	
	;Shared ID_OuvertureLibrairieFTD2XX
	Protected RetourNBBits.a, REF.a
	Global MUT_InstructionFIFO
	
	LockMutex(MUT_InstructionFIFO)
		Debug "Envoye sur le port usb N° "+Str(ID_PeripheriqueUSB)
		Debug "EnvoyeCodeBinaire : Envoye code binaire :> "+Bin(CodeATransmettre)+ " = "+Str(CodeATransmettre)
		REF = FT_Write(ID_PeripheriqueUSB,@CodeATransmettre,SizeOf(CodeATransmettre),@RetourNBBits)
		;CallFunction(ID_OuvertureLibrairieFTD2XX,"FT_Write",ID_PeripheriqueUSB,@CodeATransmettre,SizeOf(RecuperationBiT),@RetourNBBits)
	UnlockMutex(MUT_InstructionFIFO)
	ProcedureReturn REF
EndProcedure

Procedure.b SignalePortFIFO(ID_PeripheriqueUSB,Port.a,EtatPort.b=#False,Duree.i=#PB_Ignore)
	
	Protected REF.a, ConfigurationDuReveilleDuPort.ConfigReveilleActionPort, *AdresseMem
	
	;Envoye du mot binaire
	REF = EnvoyeCodeBinaire(ID_PeripheriqueUSB,EncodeBinFIFO(Port,EtatPort))
	Debug REF
	;Si durée attente puis inversion du code binaire
	If Duree > #False		
		Debug "Mise en route d'un THD pour le port FIFO"
		If EtatPort = #False
			EtatPort = #True
		Else
			EtatPort = #False
		EndIf		
		
		*AdresseMem = AllocateMemory(SizeOf(ConfigReveilleActionPort))
		
		ConfigurationDuReveilleDuPort\ID_PeripheriqueUSB = ID_PeripheriqueUSB
		ConfigurationDuReveilleDuPort\Port = Port
		ConfigurationDuReveilleDuPort\EtatPort = EtatPort
		ConfigurationDuReveilleDuPort\Duree = Duree
		
		CopyMemory(@ConfigurationDuReveilleDuPort,*AdresseMem,SizeOf(ConfigurationDuReveilleDuPort))
		Debug "--- thd"
		Debug CreateThread(@ReveilleActionPort(),*AdresseMem)
		;Attente de l'acquitement 
	EndIf
	ProcedureReturn REF
EndProcedure

Procedure.b ReveilleActionPort(*Config.ConfigReveilleActionPort)
	Debug "OK"
	
	Delay(*Config\Duree)	
	SignalePortFIFO(*Config\ID_PeripheriqueUSB,*Config\Port,*Config\EtatPort)	
	FreeMemory(*Config)
	Debug "Fin THD"
EndProcedure

Procedure.b PulseSignalePortFIFO(ID_PeripheriqueUSB.i,Port.a,EtatPortDemarrage.b=#True,DureeImpulsion.i=1,NBImpulsion.i=1)
	
	Protected ind_NBImpulsion.i, EtatPortFinImpulsion.b
	
		If EtatPortDemarrage = #True
			EtatPortFinImpulsion = #False
		Else
			EtatPortFinImpulsion = #True
		EndIf
	
	For ind_NBImpulsion = 1 To NBImpulsion
		SignalePortFIFO(ID_PeripheriqueUSB,Port,EtatPortDemarrage)
		Delay(DureeImpulsion)
		SignalePortFIFO(ID_PeripheriqueUSB,Port,EtatPortFinImpulsion)
	Next	
EndProcedure
;-----------------------------------------------------------------------------------
;- FIN
;-----------------------------------------------------------------------------------

[Backup]

lorsque tu fais :

Code : Tout sélectionner

Procedure.i ChargeLibrairieFTDI(EmplacementLibrairie$="ftd2xx.dll")   
   Define ID_OuvertureLibrairieFTD2XX.i
   ;Shared ID_OuvertureLibrairieFTD2XX.i
   
   Global FT_Open.FT_Open, FT_Close.FT_Close, FT_Write.FT_Write, FT_Read.FT_Read, FT_SetBitMode.FT_SetBitMode ; <<<<<<<<<<

dans une procedure ç'est ... comment dire ça sans te froisser ,

dans une procedure utilise Shared , qui sert a partager les variables avec (vers ) l’extérieur (donc les rends Global)
mais sémantiquement c'est pas la meme chose
peut etre bien qu'au niveau declaration, et pile non plus d'ailleurs ( j'ai la bulle de ressortir IDA )

Global n'a rien a faire dans une procedure a mon sens ..
ça sert a déclarer les variables pour l'ensemble du code (donc hors procedure) ..

dans une procedure .. on partage (ou pas ) ce qui se trouve dans une procedure avec "Shared"


recap :
Global rends les variables accessibles par tout le code
Shared : rend les variables créées dans une procédure , accessibles par tout le code


ps : Ne prends pas ça comme une remontrance .. juste comme pour le "Define" .. une information .. rien de plus

[G-Rom]

Je ne pense pas que l'arduino arrive à lire du code purebasic.

c’était pas la question.

PB est l'arduino communique très bien , après mes tests.
PB à la lib serial , l'arduino aussi , ils communique sans problèmes. faut juste pensé à temporiser
le programme PB car il va beaucoup plus vite que l'arduino.

Pour ton wifi , c'est un shield , il faudra que tu lançes tes commandes par le biais de PureBasic vers ton arduino, qui lui enverras le reste vers le shield.

PB -> Arduino -> Shield.

je ferais un programme PB qui allume et éteint une LED via l'arduino , je posterais sur le forum.

[G-Rom]

http://www.purebasic.fr/french/viewtopi ... 21&t=12716

[Backup]

http://www.purebasic.fr/french/viewtopi ... 79#p141179

[Dumli]

WOW
Merci les gas ! Franchement ça fait plaisir

Je vais étudier tout ça en détail mais une question me trotte toujours, comme faire pour le Wifi ?

Pour ton wifi , c'est un shield , il faudra que tu lançes tes commandes par le biais de PureBasic vers ton arduino, qui lui enverras le reste vers le shield.

PB -> Arduino -> Shield.

D'accord, j'ai déjà le Shield (http://www.robotshop.com/cupperhead-wif ... duino.html) mais je ne comprends pas comment PB peut envoyer des données à la Arduino en WiFi Et pour le schéma c'est pas plutôt : PB => Shield => Arduino => Shield => PB ?

Encore merci en tout cas !

[G-Rom]

non , PB n'a aucun moyen de communiquer en WIFI , il faudrait que tu passes par une lib externe à la rigueur, et encore...
le mieux pour ton cas , c'est deux arduino & 2 shield wifi , un qui commande, l'autre qui reçois, celui qui commande est relié à ton PC

[MetalOS]

Cool je ne savais pas que PB pouvais communiquer avec une carte arduino simplement avec la lib serial. Merci G-Rom

[Backup]

non , PB n'a aucun moyen de communiquer en WIFI ,

en utilisant les fonctions Reseau de Purebasic ?
lorsque j'ouvre la page de mon routeur , j'envoie bien ma requete par le wifi non ... ? !!

il suffit d'avoir un ip (192.168.0.1)

on peut aussi utiliser Telnet ...

le Wifi , du moment qu'on a une adresse et un port , c'est transparent non ?