HowTo FT232H

/**
 * Programme de test qui met en oeuvre la librairie libmpsse et le driver 
 * D2XX de chez FTDI pour piloter un rheostat numérique de chez 
 * Microship (MCP4142-10k) à travers un FT232H.
 * 
 * Le programme fixe d’abord la valeur du rheostat à sa valeur médiane
 * (0x40 : ≈5 kΩ) en appelant la fonction 'Write Data' puis
 * l’incrémente toutes les secondes jusqu’à sa valeur maximale (0x80)
 * avec la commande 'Increment Wiper'. A chaque incrément, on lit la valeur
 * effective du rheostat avec la commande 'Read Data'.
 * Dès que la valeur atteint la valeur max. du rhéostat (0x80 : ≈10kΩ),
 * le programme quite.
 * Pendant l’incrémentation, l’ohmètre doit vérifier l’augmentation de la résistance
 * de ≈5kΩ à ≈10kΩ entre les broches 5 et 6.
 * 
 * Ce programme met en oeuvre les fonctions suivantes de la libmpsse :
 * - Init_libMPSSE()
 * - SPI_GetNumChannels()
 * - SPI_GetChannelInfo()
 * - SPI_OpenChannel()
 * - SPI_InitChannel()
 * - SPI_Write()
 * - SPI_ReadWrite()
 * - SPI_CloseChannel()
 * - Cleanup_libMPSSE()
 * 
 * compilation : gcc -o mcp4142-cli mcp4142-cli.c -lmpsse
 */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <ftd2xx.h>
#include <WinTypes.h>
#include <libmpsse_spi.h>

int main() {
   FT_STATUS status;

   // Initialiser la librairie
   Init_libMPSSE();

   // Récupérer le nombre de canaux disponibles
   uint32_t numChannels;
   status = SPI_GetNumChannels(&numChannels);

   if(status != FT_OK) {
      printf("Impossible de déterminer le nombre de canaux MPSSE.\nBye!");
      Cleanup_libMPSSE();
      exit(-1);
   } else {
      printf("Nombre de canaux SPI trouvés : %d\n", numChannels);
   }

   // Afficher le détail des canaux trouvés
   FT_DEVICE_LIST_INFO_NODE channelInfo;
   uint32_t ft232hChannel = -1;
   for(int i = 0; i < numChannels; i++) {
      status = SPI_GetChannelInfo(i, &channelInfo);
      if(status != FT_OK) {
         printf("Impossible d’obtenir les détails du canal MPSSE n°%d.\nBye!", i);
         Cleanup_libMPSSE();
         exit(-1);
      } else {
         printf("Canal n° %d\n", i);
         printf(". Description\t: %s\n", channelInfo.Description);
         printf(". N° de série\t: %s\n", channelInfo.SerialNumber);
         printf(". ID\t\t: 0x%08x\n", channelInfo.ID);
         printf(". Flags\t\t: 0x%08x\n", channelInfo.Flags); /* Voir 
            https://ftdichip.com/wp-content/uploads/2023/09/D2XX_Programmers_Guide.pdf
            pour la définition des flags :
            "The flag value is a 4-byte bit map containing miscellaneous data as defined in Appendix A – Type
            Definitions. Bit 0 (least significant bit) of this number indicates if the port is open (1) or closed (0). Bit 1
            indicates if the device is enumerated as a high-speed USB device (2) or a full-speed USB device (0). The
            remaining bits (2 - 31) are reserved."
            */
         printf(". Type\t\t: %d\n", channelInfo.Type); /* Voir 
            https://docs.rs/libftd2xx/latest/libftd2xx/enum.DeviceType.html
            pour la liste des types (8=FT232H, 5=FT232R …​)
            */
         if(channelInfo.Type == 8) {
            ft232hChannel = i;
         }
      }
   }
   
   // Ouvrir le canal
   FT_HANDLE handle;
   status = SPI_OpenChannel(ft232hChannel, &handle);
   if(status != FT_OK) {
      printf("Impossible d’ouvrir le canal MPSSE n°%d associé au FT232H.\nBye!", ft232hChannel);
      Cleanup_libMPSSE();
      exit(-1);
   }  
   
   // Initialiser le canal
   ChannelConfig channelConf;
   channelConf.ClockRate = 1000000; // 1 MHz
   channelConf.LatencyTimer = 16; /* Voir
      https://ftdichip.com/wp-content/uploads/2020/08/AN232B-04_DataLatencyFlow.pdf
      pour une explication du latency timer.
      Ce délai n’a de sens que pour la lecture.
      La valeur 16ms est la valeur par défaut.
      :TODO: tenter de comprendre la signification réelle de ce paramètre
      */
   channelConf.configOptions = SPI_CONFIG_OPTION_MODE0 // SPI Mode 0
      | SPI_CONFIG_OPTION_CS_DBUS3 // xDBUS3 est utilisé comme Chip Select (CS)
      | SPI_CONFIG_OPTION_CS_ACTIVELOW // Chip Select actif à l’état bas
      ;
   channelConf.Pin = 0x00000000; /* Directions et valeurs des broches après 
      l’appel à SPI_InitChannel et SPI_CloseChannel.
      BIT7-BIT0 : Direction des broches après SPI_InitChannel (0=Input, 1=Output)
      BIT15-BIT8 : Valeurs des broches après SPI_InitChannel (0=Low, 1=High)
      BIT23-BIT16 : Direction des broches après SPI_CloseChannel (0=Input, 1=Output)
      BIT31-BIT24 : Valeurs des broches après SPI_CloseChannel (0=Low, 1=High)
      */;
   status = SPI_InitChannel(handle,&channelConf);
   if (status != FT_OK)
   {
      printf("Echec de l’initialisation du canal MPSSE n°%d associé au FT232H.\nBye!\n", ft232hChannel);
      // Fermer le canal & la librairie
      status = SPI_CloseChannel(handle);
      if(status != FT_OK) {
         printf("Erreur lors de la fermeture du canal MPSSE n°%d associé au FT232H.\n", ft232hChannel);
      }  
      Cleanup_libMPSSE();
      exit(-1);
   }   
   
   // Fixer la valeur du rheostat du MCP4142 à sa valeur médiane (0x40 ⇒ ~5kOhms)
   uint8_t inBuffer[2];
   uint8_t outBuffer[2] = {0x00, 0x40};
   uint32_t sizeToTransfer = 2;
   uint32_t sizeTransferred;
   uint32_t transferOptions = SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES // BIT0 : taille donnée en octets
      | SPI_TRANSFER_OPTIONS_CHIPSELECT_ENABLE // BIT1 : CS activé avant le transfert
      | SPI_TRANSFER_OPTIONS_CHIPSELECT_DISABLE // BIT2 : CS désactivé après le transfert
      ;
   status = SPI_Write(handle, outBuffer, sizeToTransfer, &sizeTransferred, transferOptions);
   if (status != FT_OK)
   {
      printf("Echec d’écriture du rheostat sur le canal MPSSE n°%d associé au FT232H.\nBye!\n", ft232hChannel);
      // Fermer le canal & la librairie
      status = SPI_CloseChannel(handle);
      if(status != FT_OK) {
         printf("Erreur lors de la fermeture du canal MPSSE n°%d associé au FT232H.\n", ft232hChannel);
      }  
      Cleanup_libMPSSE();
      exit(-1);
   } else {
      printf("valeur écrite avec succès\n");
   }
   
   int quit = 0;
   while(!quit) {
      
      // Incrémenter la valeur du rheostat
      outBuffer[0] = 0x04;
      sizeToTransfer = 1;
      status = SPI_Write(handle, outBuffer, sizeToTransfer, &sizeTransferred, transferOptions);
      if (status != FT_OK)
      {
         printf("Echec d’incrémentation de la valeur du rheostat sur le canal MPSSE n°%d associé au FT232H.\nBye!\n", ft232hChannel);
         // Fermer le canal & la librairie
         status = SPI_CloseChannel(handle);
         if(status != FT_OK) {
            printf("Erreur lors de la fermeture du canal MPSSE n°%d associé au FT232H.\n", ft232hChannel);
         }  
         Cleanup_libMPSSE();
         exit(-1);
      } else {
         printf("Valeur incrémentée avec succès !\n");
      }
      
      // Lire la valeur du rhéostat du MCP4142
      outBuffer[0] = 0x0C;
      outBuffer[1] = 0x00;
      sizeToTransfer = 2;
      status = SPI_ReadWrite(handle, inBuffer, outBuffer, sizeToTransfer, &sizeTransferred, transferOptions);
      if (status != FT_OK)
      {
         printf("Echec de lecture du rheostat sur le canal MPSSE n°%d associé au FT232H.\nBye!\n", ft232hChannel);
         // Fermer le canal & la librairie
         status = SPI_CloseChannel(handle);
         if(status != FT_OK) {
            printf("Erreur lors de la fermeture du canal MPSSE n°%d associé au FT232H.\n", ft232hChannel);
         }  
         Cleanup_libMPSSE();
         exit(-1);
      } else {
         uint16_t rValue = (uint16_t)(inBuffer[0] << 8) | inBuffer[1];
         printf("valeur lue : 0x%04x\n", rValue);
         if(rValue == 0xFE80) {
            break;
         }
      }
      
      sleep(1);
   }
   
   // Fermer le canal & la librairie
   status = SPI_CloseChannel(handle);
   if(status != FT_OK) {
      printf("Erreur lors de la fermeture du canal MPSSE n°%d associé au FT232H.\n", ft232hChannel);
   }  
   Cleanup_libMPSSE();
   printf("Programme terminé.\nBye !");
   
   return 0;
}