diff --git a/USB/Makefile b/USB/Makefile
new file mode 100644
index 0000000..fc3296a
--- /dev/null
+++ b/USB/Makefile
@@ -0,0 +1,25 @@
+
+export CC = gcc
+
+export LDFLAGS = -l usb-1.0
+
+
+TARGET = usb_driver
+
+
+
+C_SRC = $(wildcard *.c)
+OBJS = $(C_SRC:.c=.o)
+
+all: $(TARGET)
+
+clean:
+	rm -f *.o 
+
+
+%.o:%.c
+	$(CC) -c  $< -o $@
+
+$(TARGET): $(OBJS)
+	$(CC) -o $@ $(OBJS) $(LDFLAGS)
+
diff --git a/USB/Makefile~ b/USB/Makefile~
new file mode 100644
index 0000000..3e0dbe1
--- /dev/null
+++ b/USB/Makefile~
@@ -0,0 +1,5 @@
+tutorat : tutorat.o
+	gcc -o tutorat tutorat.o -l usb-1.0
+
+tutorat.o : tutorat.c
+	gcc -c tutorat.c
diff --git a/USB/usb_driver b/USB/usb_driver
new file mode 100755
index 0000000..8f28cb7
Binary files /dev/null and b/USB/usb_driver differ
diff --git a/USB/usb_driver.c b/USB/usb_driver.c
new file mode 100644
index 0000000..fae9656
--- /dev/null
+++ b/USB/usb_driver.c
@@ -0,0 +1,403 @@
+#include <libusb-1.0/libusb.h> //bibliothèque USB
+#include <stdio.h>
+#include <stdlib.h>
+#include <termios.h>
+#include <fcntl.h>
+#include <strings.h>
+#include <unistd.h>
+
+
+libusb_device **list;
+libusb_device_handle *handle = NULL;
+libusb_device *device;
+struct termios termios_p;
+
+
+int init_serial(char *device,int speed) //Initialisation du port série
+{
+int fd=open(device,O_RDWR);
+if(fd<0){perror(device); exit(-1);}
+//Lecture des parametres courants
+tcgetattr(fd,&termios_p);
+//On ignore les BREAK et les caracteres avec erreurs de parite
+termios_p.c_iflag = IGNBRK | IGNPAR;
+//Pas de mode de sortie particulier
+termios_p.c_oflag = 0;
+//Liaison a 9600 bps avec 7 bits de donnees et une parite paire
+termios_p.c_cflag = B9600 | CS7 | PARENB;
+//Mode non-canonique avec echo
+termios_p.c_lflag = ECHO;
+//Caracteres immediatement disponibles
+termios_p.c_cc[VMIN] = 1;
+termios_p.c_cc[VTIME] = 0;
+//Sauvegarde des nouveaux parametres
+tcsetattr(fd,TCSANOW,&termios_p);
+return fd;
+}
+
+
+void close_serial(int fd) //Fermeture du port série
+{
+tcsetattr(fd,TCSANOW,&termios_p);
+close(fd);
+}
+
+
+void callback(struct libusb_transfer *transf) //Fonction pour le transfert des instructions à la tourelle
+{
+  libusb_fill_control_setup(transf->buffer, 0xa1, 0x01, 0x300, 0x00, 0);
+  libusb_fill_control_transfer(transf, transf->dev_handle, transf->buffer, NULL, NULL, 1000);
+  fflush(stdout);
+  libusb_free_transfer(transf); //on libere la structure de transfert 
+}  
+
+void configuration_periph(libusb_device *device) //Configuration de la tourelle
+{
+  //Ouverture du pepherique
+  int status=libusb_open(device,&handle);
+  if(status!=0)
+    {
+      perror("libusb_open"); exit(-1);
+    }
+  
+  //Recuperation de la configuration d'indice 0 du périphérique
+  struct libusb_config_descriptor *config;
+  status=libusb_get_active_config_descriptor(device,&config);
+  if(status!=0)
+    {
+      perror("libusb_get_active_config_descriptor"); exit(-1);
+    }
+
+  //Interfaces
+  int i;
+  int interface;
+  
+  //Probleme noyau
+  for(i=0;i<(config->bNumInterfaces);i++)
+    {
+      if(libusb_kernel_driver_active(handle,interface))
+	{
+	  status=libusb_detach_kernel_driver(handle,interface);
+	  if(status!=0)
+	    {
+	      perror("libusb_detach_kernel_driver"); exit(-1);
+	    }
+	}
+    }
+
+  //Utilisation d'une configuration du périphérique
+  int configuration=config->bConfigurationValue;
+  printf("%d\n", configuration);
+/*
+  status=libusb_set_configuration(handle,configuration);
+  
+
+  if(status!=0)
+    {
+      perror("libusb_set_configuration"); exit(-1);
+    }
+   
+  //Claim interfaces
+  for(i=0;i<(config->bNumInterfaces);i++)
+    {
+      interface=config->interface[i].altsetting[0].bInterfaceNumber;
+      printf("Numero d'interface : %d\n", interface);
+      status=libusb_claim_interface(handle,interface);
+      if(status!=0)
+	{
+	  perror("libusb_claim_interface"); exit(-1);
+	}
+    }*/
+}
+
+
+void fermeture(libusb_device_handle *handle) //Fermeture du périphérique
+{
+  int i, interface, status;
+  libusb_device *device = libusb_get_device(handle);
+  struct libusb_config_descriptor *config;
+  status = libusb_get_active_config_descriptor(device, &config);
+  if(status != 0)
+    {
+      perror("libusb_get_active_config_descriptor");exit(-1);
+    }
+  
+  for(i=0;i<(config->bNumInterfaces);i++)
+    {
+      interface=config->interface[i].altsetting[0].bInterfaceNumber;
+      status=libusb_release_interface(handle,interface); //On libère l'interface
+      if(status!=0)
+	{
+	  perror("libusb_release_interface");
+	  exit(-1);
+	}
+      printf("Interface liberee : %d\n",interface);
+    }
+   
+  libusb_close(handle);
+  }
+
+
+void enumeration(libusb_context *context) //Enumération des périphériques USB
+{
+  int t=0;
+  libusb_device **list;
+  ssize_t count=libusb_get_device_list(context,&list);
+  if(count<0)
+    {
+      perror("libusb_get_device_list"); exit(-1);
+    }
+  ssize_t i=0;
+  for(i=0;i<count;i++)
+  {
+  libusb_device *device=list[i];
+  struct libusb_device_descriptor desc;
+  int status=libusb_get_device_descriptor(device,&desc);
+  if(status!=0) continue;
+  uint8_t bus=libusb_get_bus_number(device);
+  uint8_t address=libusb_get_device_address(device);
+  printf("Device Found @ (Bus:Address) %d:%d\n",bus,address);
+  printf("Vendor ID 0x0%x\n",desc.idVendor);
+  printf("Product ID 0x0%x\n",desc.idProduct);
+
+  if ((desc.idVendor==0x0010) && (desc.idProduct==0x1010)) //si la tourelle est trouvee parmis les peripheriques USB, on lance sa configuration
+    {
+      printf("Tourelle trouvée !\n");
+      t=1;
+      configuration_periph(device);
+    }
+  }
+  if(t==0) printf("Tourelle non connectée !\n");
+}
+
+
+void tir(libusb_device_handle *handle) //On fait appel à cette fonction quand on désire tirer dans la fonction commande
+{
+  unsigned char tab[13];
+  struct libusb_transfer *transf;
+  
+  //1ère requête
+  transf = libusb_alloc_transfer(0);
+  libusb_fill_control_setup(tab, 0x21, 0x09, 0x300, 0x00, 13);
+  tab[12] = 0x5e;
+  tab[11] = 0x00;
+  tab[10] = 0x00;
+  tab[8] = 0x00;
+  tab[9] = 0x00;
+
+  //Structure de transfert
+  libusb_fill_control_transfer(transf, handle, tab, callback, NULL, 0);
+  //Envoi sur le port serie
+  libusb_submit_transfer(transf);
+  
+  //2ème requête
+  transf = libusb_alloc_transfer(0);
+  libusb_fill_control_setup(tab, 0x21, 0x09, 0x300, 0x00, 13);
+  tab[12] = 0x5c;
+  tab[11] = 0x00;
+  tab[10] = 0x00;
+  tab[8] = 0x00;
+  tab[9] = 0x00;
+  
+  //Structure de transfert
+  libusb_fill_control_transfer(transf, handle, tab, callback, NULL, 0);
+  //Envoi sur le port serie
+  libusb_submit_transfer(transf);
+
+  //Tir
+  transf = libusb_alloc_transfer(0);
+  libusb_fill_control_setup(tab, 0x21, 0x09, 0x300, 0x00, 13);
+  tab[12] = 0xfe;
+  tab[11] = 0xff;
+  tab[10] = 0xe0;
+  tab[8] = 0x5f;
+  tab[9] = 0x10;
+
+  //Structure de transfert
+  libusb_fill_control_transfer(transf, handle, tab, callback, NULL, 0);
+  //Envoi sur le port serie
+  libusb_submit_transfer(transf);
+}
+
+
+void commande(char action, libusb_device_handle *handle) //Cette fonction permet de commander les déplacements et tirs de la tourelle
+{
+  char cmd;
+  
+  //Declaration de la structure d'envoi pour les données de la requette
+  struct libusb_transfer *transf;
+  unsigned char tab[13];
+  transf = libusb_alloc_transfer(0);
+
+  //Paramètres des requêtes
+  libusb_fill_control_setup(tab, 0x21, 0x09, 0x300, 0x00, 13);
+  
+  switch(action)
+    {
+    case 'g': //déplacement à gauche
+      cmd=0x04;
+      break;
+    case 'd': //déplacement à droite
+      cmd=0x08;
+      break;
+    case 'h': //déplacement en haut
+      cmd=0x02;
+      break;
+    case 'b': //déplacement en bas
+      cmd=0x01;
+      break;
+    case 'a': //arrêt
+      cmd=0x00;
+      break;
+    case 't': //tir
+      cmd=0x10;
+      break;
+    default :
+      printf("Commande invalide\n");
+      break;
+    }
+
+  if(cmd==0x10)//Si l'on veut tirer
+    {
+      tir(handle); //Les requêtes sont différentes pour la commande de tir (voir la fonction dédiée)
+    }
+  else
+    {
+      //Données de la requette à envoyer à la tourelle pour les mouvements. tab[9] correspond à l'action à effectuer (gauche, droite, haut, bas ou arrêt)
+      tab[12] = 0xfe;
+      tab[11] = 0xff;
+      tab[10] = 0xe0;
+      tab[8] = 0x5f;
+      tab[9] = cmd;
+   
+      //Structure de transfert
+      libusb_fill_control_transfer(transf, handle, tab, callback, NULL, 0);
+      //Envoi sur le port serie
+      libusb_submit_transfer(transf);
+    }     
+}
+ 
+     
+int main()
+{
+   //Initialisation de la bibliotheque libusb
+  libusb_context *context;
+  
+  int status=libusb_init(&context);
+  if(status!=0)
+    {
+      perror("libusb_init"); exit(-1);
+    }
+
+  enumeration(context); //Enumération des périphériques USB. Si la tourelle est trouvée, cette fonction fait appel à la fonction configuration_periph qui va configurer la tourelle.
+
+  //Initialisation du port serie
+  char *device="/dev/ttyACM0";
+  int fd=init_serial(device,B9600); //Vitesse 9600 bauds
+  printf("port init\n");
+
+
+//close_serial(fd);
+  //Menu de commande
+  char action, choix;
+  printf("\nPilotage de la tourelle\n");
+  printf("------------------------\n");
+  printf("Taper 0 pour piloter la tourelle au clavier ou 1 pour la piloter avec l'arduino : ");
+  scanf("%c",&choix);
+
+  if(choix=='0')
+    {
+      printf("\nPilotage au clavier\n");
+      printf("Taper d pour droite, g pour gauche, h pour haut, b pour bas, t pour tirer, s pour sortir du programme :\n");
+    }
+  if(choix=='1')
+    {
+      printf("\nPilotage avec l'arduino\n");
+      printf("Pour diriger la tourelle, utiliser le joystick, pour tirer appuyer dessus et pour sortir du programme appuyer sur D3.\n");
+    }
+
+  for(;;) //Boucle d'éxécution
+    { 
+      if(choix=='0') //Pilotage au clavier
+	{
+	  while(getchar() != '\n');
+	  scanf("%c",&action);
+	  switch (action)
+	    {
+	    case 's':
+	      fermeture(handle);
+	      close_serial(fd);
+	      libusb_free_device_list(list,1);
+	      libusb_exit(context);
+	      return 0;
+	      break;
+	    case 'd':
+	      commande(action, handle);
+	      sleep(1);
+	      commande('a',handle);
+	      break;
+	    case 'g':
+	      commande(action, handle);
+	      sleep(1);
+	      commande('a',handle);
+	      break;
+	    case 'h':
+	      commande(action, handle);
+	      sleep(1);
+	      commande('a',handle);
+	      break;
+	    case 'b':
+	      commande(action, handle);
+	      sleep(1);
+	      commande('a',handle);
+	      break;
+	    case 't' :
+	      commande(action, handle);
+	      sleep(1);
+	      commande('a',handle);
+	      commande(action, handle);
+	      sleep(1);
+	      commande('a',handle);
+	      commande(action, handle);
+	      sleep(1);
+	      commande('a',handle); 
+	      break;
+	    default :
+	      printf("Commande invalide ! Retaper :\n");
+	      break;
+	    }
+	}
+
+      if(choix=='1') //Pilotage avec l'arduino
+	{
+	  read(fd,&action,1); //On lit sur le port série
+	  printf("%c\n",action);
+	  write(fd,"o",1); //On envoie le caractère 'o' sur le port série en réponse
+	  commande(action,handle); //Permet de déplacer la tourelle ou d'arreter ses mouvements selon le caractère reçu (d,g,b,h ou a)
+	  if(action=='t') //Si l'on reçoit l'ordre de tirer
+	    {
+	      commande(action, handle);
+	      sleep(1);
+	      commande('a',handle);
+	      commande(action, handle);
+	      sleep(1);
+	      commande('a',handle);
+	      commande(action, handle);
+	      sleep(1);
+	      commande('a',handle);
+	    }
+	  if(action=='s') //Si l'on reçoit le caractère 's' on ferme le programme
+	    {
+	      fermeture(handle);
+	      close_serial(fd);
+	      libusb_free_device_list(list,1);
+	      libusb_exit(context);
+	      return 0;
+	    }
+	      
+    	}
+    
+    } 
+
+  return 0;
+}
diff --git a/gadget/Descriptors.c b/gadget/Descriptors.c
index 9827037..1ebf8e2 100644
--- a/gadget/Descriptors.c
+++ b/gadget/Descriptors.c
@@ -191,7 +191,7 @@ const USB_Descriptor_String_t PROGMEM ManufacturerString = USB_STRING_DESCRIPTOR
  *  and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
  *  Descriptor.
  */
-const USB_Descriptor_String_t PROGMEM ProductString = USB_STRING_DESCRIPTOR(L"LUFA USB-RS232 Adapter");
+const USB_Descriptor_String_t PROGMEM ProductString = USB_STRING_DESCRIPTOR(L"USB Gadget");
 
 /** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
  *  documentation) by the application code so that the address and size of a requested descriptor can be given
--
libgit2 0.21.2