FT_STATUS SPI_GetNumChannels (uint32 *numChannels);

FT_STATUS SPI_GetChannelInfo (uint32 index, FT_DEVICE_LIST_INFO_NODE *chanInfo);

FT_STATUS SPI_OpenChannel (uint32 index, FT_HANDLE *handle);

FT_STATUS SPI_InitChannel (FT_HANDLE handle, ChannelConfig *config);

FT_STATUS SPI_CloseChannel (FT_HANDLE handle);

FT_STATUS SPI_Read (FT_HANDLE handle,
                    uint8 *buffer,
                    uint32 sizeToTransfer,
                    uint32 *sizeTransferred,
                    uint32 transferOptions);

FT_STATUS SPI_ Write (FT_HANDLE handle,
                      uint8 *buffer,
                      uint32 sizeToTransfer,
                      uint32 *sizeTransferred,
                      uint32 transferOptions);

FT_STATUS SPI_ReadWrite (FT_HANDLE handle,
                         uint8 *inBuffer,
                         uint8 *outBuffer,
                         uint32 sizeToTransfer,
                         uint32 *sizeTransferred,
                         uint32 transferOptions);

FT_STATUS SPI_IsBusy (FT_HANDLE handle, bool *state);

FT_STATUS SPI_ChangeCS (FT_HANDLE handle, uint32 configOptions);

FT_STATUS FT_WriteGPIO (FT_HANDLE handle, uint8 dir, uint8 value);

FT_STATUS FT_ReadGPIO (FT_HANDLE handle, uint8 *value);

void Init_libMPSSE (void);

void Cleanup_libMPSSE (void);

/* Структура, содержащая информацию о конфигурации канала SPI. Она заполняется

в приложении пользователя во время инициализации канала, затем сохраняется

в связанный список и используется внутри других функций SPI при выполнении

их операций. Эта структура удаляется из списка, когда приложение пользователя

вызовет SPI_CloseChannel. */

typedef struct ChannelConfig_t
{
   DWORD	ClockRate; /* частота тактов SPI, должно быть меньше или равна 30000000 */
   UCHAR	LatencyTimer; /* значение в миллисекундах, значение должно быть меньше

                          или равно 255 */
   DWORD	configOptions;/* Это поле предоставляет способ разрешить/запретить

                          отдельные функции, связанные с протоколом, как он

                          реализован в микросхеме.

   BIT1-0=CPOL-CPHA: 00 - MODE0 - data captured on rising edge, propagated on falling

                     01 - MODE1 - data captured on falling edge, propagated on rising

                     10 - MODE2 - data captured on falling edge, propagated on rising

                     11 - MODE3 - data captured on rising edge, propagated on falling

   BIT4-BIT2: 000 - A/B/C/D_DBUS3 = ChipSelect

            : 001 - A/B/C/D_DBUS4 = ChipSelect

            : 010 - A/B/C/D_DBUS5 = ChipSelect

            : 011 - A/B/C/D_DBUS6 = ChipSelect

            : 100 - A/B/C/D_DBUS7 = ChipSelect

   BIT5: для ChipSelect активный уровень 1, если этот бит равен 0

   BIT6-BIT31: зарезервировано

   */
   DWORD Pin;/* BIT7  - BIT0:  начальное направление работы ножек порта    */
             /* BIT15 - BIT8:  начальные уровни ножек порта                */
             /* BIT23 - BIT16: конечное направление работы ножек порта     */
             /* BIT31 - BIT24: конечные уровни ножек порта                 */
   USHORT currentPinState;/* BIT7  - BIT0: текущее направление ножек порта */
                          /* BIT15 - BIT8: текущие уровни ножек порта      */
}ChannelConfig;

/*!

 * \file sample-static.c

 *

 * \author FTDI

 * \date 20110512

 *

 * Copyright © 2011 Future Technology Devices International Limited

 *

 * Проект: libMPSSE

 * Модуль: SPI Sample Application - подключение 94LC56B SPI EEPROM

 * \sa Даташит 93LC56B http://ww1.microchip.com/downloads/en/DeviceDoc/21794F.pdf

 *

 * История ревизий:

 * 0.1 - 20110512 - начальная версия

 * 0.2 - 20110801 - изменено LatencyTimer на 255

 *                  делается попытка открыть канал, только если он доступен

 *                  добавлены и изменены макросы

 *                  подключен stdlib.h

 * 0.3 - 20111212 - добавлены комментарии

 */

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

/* Подключаемые заголовки                                                     */

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

/* Стандартные библиотеки C */

#include < stdio.h>

#include < stdlib.h>

/* Библиотеки, специфичные для OS */

#ifdef _WIN32

#include < windows.h>

#endif

/* Заголовок для драйвера D2XX */

#include "ftd2xx.h"

/* Заголовок libMPSSE */

#include "libMPSSE_spi.h"

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

/* Определение макросов и типов                                               */

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

/* Вспомогательные макросы */

#define APP_CHECK_STATUS(exp) {if(exp!=FT_OK){printf("%s:%d:%s(): status(0x%x) \

!= FT_OK\n",__FILE__, __LINE__, __FUNCTION__,exp);exit(1);}else{;}};

#define CHECK_NULL(exp){if(exp==NULL){printf("%s:%d:%s(): NULL expression \

encountered \n",__FILE__, __LINE__, __FUNCTION__);exit(1);}else{;}};

/* Определение макросов, специфичных для приложения */

#define SPI_DEVICE_BUFFER_SIZE 256

#define SPI_WRITE_COMPLETION_RETRY 10

#define START_ADDRESS_EEPROM 0x00 /* начальный адрес read/write внутри EEPROM */

#define END_ADDRESS_EEPROM 0x10

#define RETRY_COUNT_EEPROM 10     /* количество повторны попыток, если была неудача read/write */

#define CHANNEL_TO_OPEN 0         /* 0 для первого доступного канала, 1 для следующего, и т. д. */

#define SPI_SLAVE_0 0

#define SPI_SLAVE_1 1

#define SPI_SLAVE_2 2

#define DATA_OFFSET 3

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

/* Глобальные переменные                                                      */

/******************************************************************************/
uint32 channels;
FT_HANDLE ftHandle;
ChannelConfig channelConf;
uint8 buffer[SPI_DEVICE_BUFFER_SIZE];

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

/* Определение публичных функций                                              */

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

/*!

 * \brief Чтение EEPROM

 *

 * Эта функция прочитает байты по указанному адресу в 93LC56B EEPROM

 *

 * \param[in] address адрес, куда запишется байт

 * \param[in] data указатель, куда пишутся прочитанные байты

 * \return Возвратит код состояния FT_STATUS (см. D2XX Programmer's Guide, или [4])

 */
FT_STATUS read_byte (uint8 address, uint16 *data)
{
   uint32 sizeToTransfer = 0;
   uint32 sizeTransfered;
   bool writeComplete = 0;
   uint32 retry = 0;
   bool state;
   FT_STATUS status;

   /* CS_High + Write command + Address */
   sizeToTransfer = 1;
   sizeTransfered = 0;
   buffer[0] = 0xC0; /* Команда чтения (3 бита) */
   // Добавление 5 старших бит:
   buffer[0] = buffer[0] | ( ( address >> 3) & 0x0F );
   status = SPI_Write(ftHandle, buffer, sizeToTransfer, &sizeTransfered,
   SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES|
   SPI_TRANSFER_OPTIONS_CHIPSELECT_ENABLE);
   APP_CHECK_STATUS(status);

   /* Запись части бит адреса */
   sizeToTransfer = 4;
   sizeTransfered = 0;
   // Остальные 3 младших бита адреса:
   buffer[0] = ( address & 0x07 ) << 5;
   status = SPI_Write(ftHandle, buffer, sizeToTransfer, &sizeTransfered,
   SPI_TRANSFER_OPTIONS_SIZE_IN_BITS);
   APP_CHECK_STATUS(status);

   /* Чтение 2 байт */
   sizeToTransfer = 2;
   sizeTransfered = 0;
   status = SPI_Read(ftHandle, buffer, sizeToTransfer, &sizeTransfered,
   SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES|
   SPI_TRANSFER_OPTIONS_CHIPSELECT_DISABLE);
   APP_CHECK_STATUS(status);

   *data = (uint16)(buffer[1] << 8);
   *data = (*data & 0xFF00) | (0x00FF & (uint16)buffer[0]);

   return status;
}

/*!

 * \brief Запись EEPROM

 *

 * Эта функция запишет байты по указанному адресу в 93LC56B EEPROM

 *

 * \param[in] address адрес памяти в EEPROM

 * \param[in] data указатель, откуда берутся записываемые байты

 * \return Returns status code of type FT_STATUS(see D2XX Programmer's Guide)

 * \return Возвратит код состояния FT_STATUS (см. D2XX Programmer's Guide, или [4])

 */
FT_STATUS write_byte (uint8 address, uint16 data)
{
   uint32 sizeToTransfer = 0;
   uint32 sizeTransfered = 0;
   bool writeComplete = 0;
   uint32 retry = 0;
   bool state;
   FT_STATUS status;

   /* Запись команды EWEN (с сигналом выборки CS_High -> CS_Low) */
   sizeToTransfer = 11;
   sizeTransfered = 0;
   buffer[0] = 0x9F;/* SPI_EWEN -> binary 10011xxxxxx (11 бит) */
   buffer[1] = 0xFF;
   status = SPI_Write(ftHandle, buffer, sizeToTransfer, &sizeTransfered,
                      SPI_TRANSFER_OPTIONS_SIZE_IN_BITS|
                      SPI_TRANSFER_OPTIONS_CHIPSELECT_ENABLE|
                      SPI_TRANSFER_OPTIONS_CHIPSELECT_DISABLE);
   APP_CHECK_STATUS(status);

   /* CS_High + Write command + Address */
   sizeToTransfer = 1;
   sizeTransfered = 0;
   buffer[0] = 0xA0; /* Команда записи (3 бита) */
   // Добавление 5 старших бит:
   buffer[0] = buffer[0] | ( ( address >> 3) & 0x0F );
   status = SPI_Write(ftHandle, buffer, sizeToTransfer, &sizeTransfered,
                      SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES|
                      SPI_TRANSFER_OPTIONS_CHIPSELECT_ENABLE);
   APP_CHECK_STATUS(status);

   /* Запись 3 младших бит адреса */
   sizeToTransfer = 3;
   sizeTransfered = 0;
   buffer[0] = ( address & 0x07 ) << 5;   // младшие 3 бита адреса
   status = SPI_Write(ftHandle, buffer, sizeToTransfer, &sizeTransfered,
                      SPI_TRANSFER_OPTIONS_SIZE_IN_BITS);
   APP_CHECK_STATUS(status);

   /* Запись 2 байт данных + CS_Low */
   sizeToTransfer = 2;
   sizeTransfered = 0;
   buffer[0] = (uint8)(data & 0xFF);
   buffer[1] = (uint8)((data & 0xFF00)>>8);
   status = SPI_Write(ftHandle, buffer, sizeToTransfer, &sizeTransfered,
                      SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES|
                      SPI_TRANSFER_OPTIONS_CHIPSELECT_DISABLE);
   APP_CHECK_STATUS(status);

   /* Ожидание перехода D0 в лог. 1 */

#if 1
   /* Strobe Chip Select */
   sizeToTransfer = 0;
   sizeTransfered = 0;
   status = SPI_Write(ftHandle, buffer, sizeToTransfer, &sizeTransfered,
                      SPI_TRANSFER_OPTIONS_SIZE_IN_BITS|
                      SPI_TRANSFER_OPTIONS_CHIPSELECT_ENABLE);
   APP_CHECK_STATUS(status);

#ifndef __linux__
   Sleep(10);

#endif
   sizeToTransfer = 0;
   sizeTransfered = 0;
   status = SPI_Write(ftHandle, buffer, sizeToTransfer, &sizeTransfered,
                      SPI_TRANSFER_OPTIONS_SIZE_IN_BITS|
                      SPI_TRANSFER_OPTIONS_CHIPSELECT_DISABLE);
   APP_CHECK_STATUS(status);

#else
   retry = 0;
   state = FALSE;
   SPI_IsBusy(ftHandle, &state);
   while((FALSE==state) && (retry < SPI_WRITE_COMPLETION_RETRY))
   {
      printf("SPI device is busy(%u)\n", (unsigned)retry);
      SPI_IsBusy(ftHandle, &state);
      retry++;
   }

#endif
   /* Запись команды EWEN(with CS_High -> CS_Low) */
   sizeToTransfer = 11;
   sizeTransfered = 0;
   buffer[0] = 0x8F;   /* SPI_EWEN -> binary 10011xxxxxx (11 бит) */
   buffer[1] = 0xFF;
   status = SPI_Write(ftHandle, buffer, sizeToTransfer, &sizeTransfered,
                      SPI_TRANSFER_OPTIONS_SIZE_IN_BITS|
                      SPI_TRANSFER_OPTIONS_CHIPSELECT_ENABLE|
                      SPI_TRANSFER_OPTIONS_CHIPSELECT_DISABLE);
   APP_CHECK_STATUS(status);

   return status;
}

/*!

 * \brief Точка входа в приложение примера.

 *

 * Эта функция откроет канал, запишет данные в EEPROM, и прочитает

 *

 данные обратно.

 *

 * \return Вернет 0 в случае успеха

 */

int main()
{
   FT_STATUS status;
   FT_DEVICE_LIST_INFO_NODE devList;
   uint8 address = 0;
   uint16 data;
   int i, j;

#ifdef _MSC_VER
   Init_libMPSSE();

#endif
   channelConf.ClockRate = 5000;
   channelConf.LatencyTimer = 255;
   channelConf.configOptions = SPI_CONFIG_OPTION_MODE0 | SPI_CONFIG_OPTION_CS_DBUS3;
   /* FinalVal-FinalDir-InitVal-InitDir (для 0=in, 1=out) */
   channelConf.Pin = 0x00000000;

   status = SPI_GetNumChannels(&channels);
   APP_CHECK_STATUS(status);
   printf("Number of available SPI channels = %d\n", channels);

   if(channels>0)
   {
      for(i=0; i < channels; i++)
      {
         status = SPI_GetChannelInfo(i, &devList);
         APP_CHECK_STATUS(status);
         printf("Information on channel number %d:\n", i);
         /* Печать информации об устройстве */
         printf(" Flags=0x%x\n", devList.Flags);
         printf(" Type=0x%x\n", devList.Type);
         printf(" ID=0x%x\n", devList.ID);
         printf(" LocId=0x%x\n", devList.LocId);
         printf(" SerialNumber=%s\n", devList.SerialNumber);
         printf(" Description=%s\n", devList.Description);
         // ftHandle == 0, если канал не открыт:
         printf(" ftHandle=0x%x\n", devList.ftHandle);
      }

      /* Открытие первого доступного канала */
      status = SPI_OpenChannel(CHANNEL_TO_OPEN, &ftHandle);
      APP_CHECK_STATUS(status);
      printf("\nhandle=0x%x status=0x%x\n", ftHandle, status);
      status = SPI_InitChannel(ftHandle, &channelConf);
      APP_CHECK_STATUS(status);

      for(address=START_ADDRESS_EEPROM; address < END_ADDRESS_EEPROM; address++)
      {
         printf("writing address = %d data = %d\n", address,
                                                    address+DATA_OFFSET);
         write_byte(address, (uint16)address+DATA_OFFSET);
      }

      for(address=START_ADDRESS_EEPROM; address < END_ADDRESS_EEPROM; address++)
      {
         read_byte(address, &data);
         read_byte(address, &data);
         printf("reading address=%d data=%d\n", address, data);
      }

      status = SPI_CloseChannel(ftHandle);
   }

#ifdef _MSC_VER
   Cleanup_libMPSSE();

#endif
   return 0;
}