[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-wifi-shield-arduino.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 · **Inscription:** Dim 10/Jan/2010 5:29 **Messages:** 2135

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 · **Inscription:** Mar 24/Nov/2009 10:34 **Messages:** 31

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 · **Inscription:** Mar 24/Nov/2009 10:34 **Messages:** 31

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:

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

Dobro · **Inscription:** Lun 26/Avr/2004 0:40 **Messages:** 12954

lorsque tu fais :

Code:

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 :lol:

)

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 · **Inscription:** Dim 10/Jan/2010 5:29 **Messages:** 2135

Citation:

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 · **Inscription:** Dim 10/Jan/2010 5:29 **Messages:** 2135

http://www.purebasic.fr/french/viewtopic.php?f=21&t=12716

Dobro · **Inscription:** Lun 26/Avr/2004 0:40 **Messages:** 12954

viewtopic.php?f=9&t=3588&p=141179#p141179

:lol:

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 ?

Citation:

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-wifi-shield-arduino.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 ? :lol:

Encore merci en tout cas !

G-Rom · **Inscription:** Dim 10/Jan/2010 5:29 **Messages:** 2135

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 :wink:

Dobro · **Inscription:** Lun 26/Avr/2004 0:40 **Messages:** 12954

G-Rom a écrit:

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 ?

PureBasic

[RESOLU] SerialPort et WiFi

Qui est en ligne