PureBasic

Code : Tout sélectionner

EnableExplicit

#PORT = 1000        ;port d'ecoute
#MAXDATASIZE = 100  ;taille maximale que WiShield peut envoyer en une seule fois

Procedure main()
  Protected sockfd.i, nbBytes.i, *buffer, srv.SOCKADDR_IN, buffer_len.i, name.s
  
  OpenConsole()
  *buffer = AllocateMemory(#MAXDATASIZE)
  
  srv\sin_family = #AF_INET
  srv\sin_port = htons_(#PORT)
  srv\sin_addr = MakeIPAddress(192, 168, 1, 2)  ;ip 192.168.1.2
  
  sockfd = SOCKET_(#PF_INET, #SOCK_STREAM, #IPPROTO_TCP)
  If sockfd = -1
    PrintN("Erreur lors de la creation du socket")
    ProcedureReturn 1
  EndIf
  
  If connect_(sockfd, @srv, SizeOf(SOCKADDR_IN)) = -1
    PrintN("Erreur lors de la connexion")
    ProcedureReturn 2
  EndIf
  PrintN("Connecté au WiShield")
  
  ;Attente du message d'accueil
  If (nbBytes = recv_(sockfd, *buffer, #MAXDATASIZE, 0)) = -1
    PrintN("Erreur lors de la reception du message d'accueil")
    ProcedureReturn 3
  EndIf
  PrintN(PeekS(*buffer, nbBytes))
  
  ;récupération du nom
  name = Input()
  name + #LF$
  
  ;Envoi de la réponse
  If send_(sockfd, @name, Len(name)+1, 0) = -1
    PrintN("Erreur lors de l'envoi de la réponse")
    closesocket_(sockfd)
    ProcedureReturn 4
  EndIf
  
  ;Récuperation de la réponse
  Repeat
    If (nbBytes = recv_(sockfd, *buffer, #MAXDATASIZE, 0)) = -1
      PrintN("Erreur lors de la reception")
      ProcedureReturn 5
    EndIf
    PrintN(PeekS(*buffer, nbBytes))
    
    If PeekS(*buffer+nbBytes-1, 1) = #LF$
      Break
    EndIf
  ForEver
  
  ;fermeture de la connexion
  closesocket_(sockfd)
  
  ProcedureReturn 0
EndProcedure
  
  
main()
Input()
End

Code : Tout sélectionner

sockfd = SOCKET_(#PF_INET, #SOCK_STREAM, #IPPROTO_TCP)
  If sockfd = -1
    PrintN("Erreur lors de la creation du socket")
    ProcedureReturn 1
  EndIf

Code : Tout sélectionner

#!/usr/bin/python

import socket
import time

HOST = '192.168.0.100'     # The remote host
PORT = 1000               # The same port as used by the server

def sendValue(value):
   s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   s.connect((HOST, PORT))
   s.send(str(value) + '\n')
   s.close()

sendValue(1)
time.sleep(1)
sendValue("1")

sendValue(2)
time.sleep(1)
sendValue("2")

sendValue(3)
time.sleep(1)
sendValue("3")

sendValue(4)
time.sleep(1)
sendValue("4")

sendValue(5)
time.sleep(1)
sendValue("5")

sendValue(6)
time.sleep(1)
sendValue("6")

Code : Tout sélectionner

/*
* Socket App
 *
 * A simple socket application example using the WiShield 1.0
 */

#include <WiShield.h>

//Wireless configuration defines ----------------------------------------
#define WIRELESS_MODE_INFRA   1
#define WIRELESS_MODE_ADHOC   2

//Wireless configuration parameters ----------------------------------------
unsigned char local_ip[]       = {
  192,168,0,100};  // IP address of WiShield
unsigned char gateway_ip[]     = {
  192,168,0,47};     // router or gateway IP address
unsigned char subnet_mask[]    = {
  255,255,255,0}; // subnet mask for the local network
const prog_char ssid[] PROGMEM = {
  "JPPW"};    // max 32 bytes
unsigned char security_type    = 2;               // 0 - open; 1 - WEP; 2 - WPA; 3 - WPA2
// WPA/WPA2 passphrase
const prog_char security_passphrase[] PROGMEM = {
  "0123456789"};   // max 64 characters
// WEP 128-bit keys
prog_uchar wep_keys[] PROGMEM = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Key 0
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Key 1
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Key 2
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; // Key 3
// setup the wireless mode
// infrastructure - connect to AP
// adhoc - connect to another WiFi device
unsigned char wireless_mode = WIRELESS_MODE_INFRA;
unsigned char ssid_len;
unsigned char security_passphrase_len;
// End of wireless configuration parameters ----------------------------------------

char recvChar;

void setup()
{
  //set up serial communications
  Serial.begin(9600);
  pinMode(4, OUTPUT);

  //set up global recvChar to indicate nothing received
  recvChar = NULL;
  WiFi.init();
}

void loop()
{
  if(NULL != recvChar) {
    Serial.print("Received: ");
    Serial.print(recvChar);
    Serial.print(" [");

    switch(recvChar) {
    case '1':
      Serial.println("forward]");
      digitalWrite(4, HIGH); //-------------------------------------------------- ICI commande du PIN 4 -------------------------------------------------------------
      Serial.println("Commande envoyée");
      delay(300);
      break;
    case '2':
      Serial.println("backward]");
      break;
    case '3':
      Serial.println("turn right]");
      break;
    case '4':
      Serial.println("turn left]");
      //your control code goes here...
      break;
    case '5':
      Serial.println("stop]");
      break;
    default:
      Serial.println("unexpected value received]");
      break;
    }

    //we have handled the last data receive so clear recvChar so that we don't handle the same data again.
    recvChar = NULL;
  }

  WiFi.run();
}

Code : Tout sélectionner

/******************************************************************************

  Filename:      socketapp.c
  Description:   Simple socket programming example for the WiShield 1.0

******************************************************************************

  TCP/IP stack and driver for the WiShield 1.0 wireless devices

  Copyright(c) 2009 Async Labs Inc. All rights reserved.

  This program is free software; you can redistribute it and/or modify it
  under the terms of version 2 of the GNU General Public License as
  published by the Free Software Foundation.

  This program is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc., 59
  Temple Place - Suite 330, Boston, MA  02111-1307, USA.

  Contact Information:
  <asynclabs@asynclabs.com>

   Author               Date        Comment
  ---------------------------------------------------------------
   AsyncLabs         06/06/2009   Initial version

*****************************************************************************/

/*
* This is a short example of how to write uIP applications using
* protosockets.
*/

/*
* We define the application state (struct socket_app_state) in the
* socketapp.h file, so we need to include it here. We also include
* uip.h (since this cannot be included in socketapp.h) and
* <string.h>, since we use the memcpy() function in the code.
*/
#include "socketapp.h"
#include "uip.h"
#include <string.h>

extern char recvChar;

/*
* Declaration of the protosocket function that handles the connection
* (defined at the end of the code).
*/
static int handle_connection(struct socket_app_state *s);
/*---------------------------------------------------------------------------*/
/*
* The initialization function. We must explicitly call this function
* from the system initialization code, some time after uip_init() is
* called.
*/
void socket_app_init(void)
{
   /* We start to listen for connections on TCP port 1000. */
   uip_listen(HTONS(1000));
}
/*---------------------------------------------------------------------------*/
/*
* In socketapp.h we have defined the UIP_APPCALL macro to
* socket_app_appcall so that this function is uIP's application
* function. This function is called whenever an uIP event occurs
* (e.g. when a new connection is established, new data arrives, sent
* data is acknowledged, data needs to be retransmitted, etc.).
*/
void socket_app_appcall(void)
{
   /*
    * The uip_conn structure has a field called "appstate" that holds
    * the application state of the connection. We make a pointer to
    * this to access it easier.
    */
   struct socket_app_state *s = &(uip_conn->appstate);

   /*
    * If a new connection was just established, we should initialize
    * the protosocket in our applications' state structure.
    */
   if(uip_connected()) {
      PSOCK_INIT(&s->p, s->inputbuffer, sizeof(s->inputbuffer));
   }

   /*
    * Finally, we run the protosocket function that actually handles
   * the communication. We pass it a pointer to the application state
   * of the current connection.
   */
   handle_connection(s);
}
/*---------------------------------------------------------------------------*/
/*
* This is the protosocket function that handles the communication. A
* protosocket function must always return an int, but must never
* explicitly return - all return statements are hidden in the PSOCK
* macros.
*/
static int handle_connection(struct socket_app_state *s)
{
   if(uip_newdata()) {
      PSOCK_BEGIN(&s->p);
      PSOCK_READTO(&s->p, '\n');
      recvChar = s->inputbuffer[0];
      PSOCK_CLOSE(&s->p);
      PSOCK_END(&s->p);
   }
   else {
      //if no new data is received set our global into to 0 to indicate no new data
      recvChar = NULL;
   }
}
/*---------------------------------------------------------------------------*/

Code : Tout sélectionner

#!/usr/bin/python
# -*- coding: cp1252 -*-

import socket
import time
import pythoncom, pyHook

HOST = '192.168.0.100'     # IP du WiShield
PORT = 1000                # Port du serveur ET du WiShield utilisé
delay = 1                 # Délai d'attente pour la Arduino
key = ""

print("Mise en place des définitions ...")

def sendValue(value):
   print("En attente de création du socket ...")
   s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   print("Socket créé avec succés")
   print("En attente de connexion ...")
   s.connect((HOST, PORT))
   print("Serveur connecté au WiShield [" + str(HOST) + "] et écoute le port : " + str(PORT))
   s.send(value + '\n')
   s.close()

print("sendValue : OK")

def OnKeyboardEvent(event):
   key = event.GetKey()
   print("En attente d'envoi du message ...") 
   sendValue(key)
   print("Message envoyé : " + key + " !")

print("OnKeyboardEvent : OK")

def key() :
   # create a hook manager
   hm = pyHook.HookManager()
   # watch for all keyboard events
   hm.KeyDown = OnKeyboardEvent
   # set the hook
   hm.HookKeyboard()
   # wait forever
   pythoncom.PumpMessages()

print("key : OK")

while 1:
   print("Mise en route de l'essai ...")
   print("Saisie des touches opérationnel !")
   key()

Code : Tout sélectionner

EnableExplicit
InitNetwork()

#PORT = 1000        ;Port d'ecoute
#MAXDATASIZE = 100  ;Taille maxiamale d'envoi

Procedure main()
  Protected sockfd.i, nbBytes.i, *buffer, srv.SOCKADDR_IN, buffer_len.i, name.s
  
  OpenConsole()
  *buffer = AllocateMemory(#MAXDATASIZE)
  
  srv\sin_family = #AF_INET
  srv\sin_port = htons_(#PORT)
  srv\sin_addr = MakeIPAddress(192, 168, 0, 100)  ;IP Adresse du WiShield
  
  PrintN("Connection en cours ...")
  
  sockfd = SOCKET_(#PF_INET, #SOCK_STREAM, 0)
  If sockfd = -1
    PrintN("Erreur lors de la creation du socket")
    ProcedureReturn 1
  EndIf
  
  If connect_(sockfd, @srv, SizeOf(SOCKADDR_IN)) = -1
    PrintN("Erreur lors de la connexion")
    ProcedureReturn 2
  EndIf
  PrintN("Connection au Wishield etablie !")
  PrintN("Deconnexion et lancement de la procedure ...")
  closesocket_(sockfd)
  
  Repeat
    
    PrintN("Début de la procédure d'envoi !") ;--------------------------------------Bloque au 2nd passage ici---------------------------------------
    
    sockfd = SOCKET_(#PF_INET, #SOCK_STREAM, 0)
    If sockfd = -1
      PrintN("Erreur lors de la creation du socket")
      ProcedureReturn 1
    EndIf
    
    If connect_(sockfd, @srv, SizeOf(SOCKADDR_IN)) = -1
      PrintN("Erreur lors de la connexion")
      ProcedureReturn 2
    EndIf
    
    PrintN("Commande à envoyer (L/R/U/D) : ")
    name = Input()
    name + #LF$
    
    ;Envoi de la réponse
    If send_(sockfd, @name, Len(name)+1, 0) = -1
      PrintN("Erreur lors de l'envoi de la reponse")
      closesocket_(sockfd)
      ProcedureReturn 4
    EndIf
    
  ForEver
  
  ;fermeture de la connexion
  closesocket_(sockfd)
  
  ProcedureReturn 0
EndProcedure

main()
Input()
End

Code : Tout sélectionner

*Buffer = Input()

Code : Tout sélectionner

  ;fermeture de la connexion
  closesocket_(sockfd)

Code : Tout sélectionner

*BufferMemoire = allocatememory(4) ; 4 car un float fait 4 octets
pokef(*BufferMemoire, #pi) // stock
debug peekf(*BufferMemoire)// lecture 

Code : Tout sélectionner

IPDRONE$    = "192.168.0.100"
PORTDRONE.i = 1000

InitNetwork()

Connection = OpenNetworkConnection(IPDRONE$,PORTDRONE,#PB_Network_TCP)


*FORWARD_CMD  = AllocateMemory(1)
*BACKWARD_CMD = AllocateMemory(1)
*LEFT_CMD     = AllocateMemory(1)
*RIGHT_CMD    = AllocateMemory(1)

; ATTENTION A LA CASE !   Z != z
PokeC(*FORWARD_CMD,  Asc("z"))
PokeC(*BACKWARD_CMD, Asc("s"))
PokeC(*LEFT_CMD,     Asc("q"))
PokeC(*RIGHT_CMD,    Asc("d"))


If Connection
  
  
  ; On avance
  SendNetworkData(Connection, *FORWARD_CMD , SizeOf(*FORWARD_CMD) )
  
  ; on attend une seconde
  Delay(1000)
  
  ; on va à droite
  SendNetworkData(Connection, *RIGHT_CMD , SizeOf(*RIGHT_CMD) )
  
    
  
EndIf