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