// SPITEST.cpp: консольное приложение VC++.

// Это проект примера, использующий канал A микросхемы FT2232H для доступа

// к SPI EEPROM 93C56. Мы посылаем 16 слов данных в 93C56 и читаем их обратно,

// пользователь может увидеть результат теста в командном режиме.

#include "stdafx.h"

#include < windows.h >

#include "FTD2XX.h"

#include < stdlib.h >

// Декларирование параметров для 93C56:

#define MemSize 16   // определение количества данных, которые нужно послать

const BYTE SPIDATALENGTH = 11;   //3 бита команды + 8 бит адреса

const BYTE READ = '\xC0';        //110xxxxx

const BYTE WRITE = '\xA0';       //101xxxxx

const BYTE WREN = '\x98';        //10011xxx

const BYTE ERAL = '\x90';        //10010xxx

// Декларации для команды BAD:

const BYTE AA_ECHO_CMD_1         = '\xAA';

const BYTE AB_ECHO_CMD_2         = '\xAB';

const BYTE BAD_COMMAND_RESPONSE  = '\xFA';

//Декларации для команд MPSSE:

const BYTE MSB_RISING_EDGE_CLOCK_BYTE_OUT    = '\x10';

const BYTE MSB_FALLING_EDGE_CLOCK_BYTE_OUT   = '\x11';

const BYTE MSB_RISING_EDGE_CLOCK_BIT_OUT     = '\x12';

const BYTE MSB_FALLING_EDGE_CLOCK_BIT_OUT    = '\x13';

const BYTE MSB_RISING_EDGE_CLOCK_BYTE_IN     = '\x20';

const BYTE MSB_RISING_EDGE_CLOCK_BIT_IN      = '\x22';

const BYTE MSB_FALLING_EDGE_CLOCK_BYTE_IN    = '\x24';

const BYTE MSB_FALLING_EDGE_CLOCK_BIT_IN     = '\x26';

// Статус, определяемый драйвером D2XX, чтобы показать результат операции:
FT_STATUS ftStatus;

// Буфер, где содержатся команды MPSSE и данные для отправки в FT2232H:
BYTE OutputBuffer[512];

// Буфер, где содержатся байты данных, прочитанные из FT2232H:
BYTE InputBuffer[512];

// Значение для делителя тактов, частота SCL = 60/((1+29)*2) = 1 МГц
DWORD dwClockDivisor = 29;

// Индекс выходного буфера:
DWORD dwNumBytesToSend = 0;

// Счетчики байт:
DWORD dwNumBytesSent = 0, dwNumBytesRead = 0, dwNumInputBuffer = 0;
BYTE ByteDataRead;
WORD MemAddress = 0x00;

WORD i=0;
WORD DataOutBuffer[MemSize];
WORD DataInBuffer[MemSize];

// Эта подпрограмма используется для разрешения работы устройства SPI.

void SPI_CSEnable()
{
   // Одна команда 0x80 займет 0.2 мкс, повторяем её 5 раз, чтобы остаться в этой
   // ситуации в течение 1 мкс.
   for(int loop=0; loop < 5; loop++)
   {
      OutputBuffer[dwNumBytesToSend++] = '\x80';   // команда GPIO для ADBUS
      OutputBuffer[dwNumBytesToSend++] = '\x08';   // перевод CS в лог. 1, MOSI и SCLK в лог. 0
      OutputBuffer[dwNumBytesToSend++] = '\x0b';   // bit3:CS, bit2:MISO, bit1:MOSI, bit0:SCLK
   }
}

// Эта подпрограмма используется для запрещения работы устройства SPI.

void SPI_CSDisable()
{
   // Одна команда 0x80 займет 0.2 мкс, повторяем её 5 раз, чтобы остаться в этой
   // ситуации в течение 1 мкс.
   for(int loop=0; loop < 5; loop++)
   {
      OutputBuffer[dwNumBytesToSend++] = '\x80';   // команда GPIO для ADBUS
      OutputBuffer[dwNumBytesToSend++] = '\x00';   // перевод CS, MOSI и SCLK в лог. 0
      OutputBuffer[dwNumBytesToSend++] = '\x0b';   // bit3:CS, bit2:MISO, bit1:MOSI, bit0:SCLK
   }
}

// Эта подпрограмма используется для отправки команды в 93C56 EEPROM.
FT_STATUS WriteEECmd(FT_HANDLE ftHandle, BYTE command)
{
   dwNumBytesSent=0;
   SPI_CSEnable();
   //SPIDATALENGTH = 11, это можно поделить на 8+3 бита
   OutputBuffer[dwNumBytesToSend++] = MSB_FALLING_EDGE_CLOCK_BIT_OUT;
   OutputBuffer[dwNumBytesToSend++] = 7;  //7+1 = 8
   OutputBuffer[dwNumBytesToSend++] = command;
   OutputBuffer[dwNumBytesToSend++] = MSB_FALLING_EDGE_CLOCK_BIT_OUT;
   OutputBuffer[dwNumBytesToSend++] = SPIDATALENGTH - (8+1);
   OutputBuffer[dwNumBytesToSend++] = '\xff';
   SPI_CSDisable();
   // Отправка команды в MPSSE:
   ftStatus = FT_Write(ftHandle, OutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0;   // Очистка выходного буфера
   return ftStatus;
}

// Эта подпрограмма используется для инициализации интерфейса SPI.
BOOL SPI_Initial(FT_HANDLE ftHandle)
{
   DWORD dwCount;
   ftStatus = FT_ResetDevice(ftHandle);   // Сброс устройства USB.
   // Сначала очищается буфер приема USB путем вычитывания всех старых данных
   // из буфера приема FT2232H.
   // Получение количества байт в буфере приема FT2232H:
   ftStatus |= FT_GetQueueStatus(ftHandle, &dwNumInputBuffer);
   if ((ftStatus == FT_OK) && (dwNumInputBuffer > 0))
   {
      // Чтение данных из буфера приема FT2232H:
      ftStatus |= FT_Read(ftHandle, InputBuffer, dwNumInputBuffer, &dwNumBytesRead);
   }
   // Установка размера запроса USB (request transfer size):
   ftStatus |= FT_SetUSBParameters(ftHandle, 65535, 65535);
   // Запрет символов события и ошибки (event and error characters):
   ftStatus |= FT_SetChars(ftHandle, false, 0, false, 0);
   // Установка таймаутов чтения и записи для FT2232H на 3 секунды:
   ftStatus |= FT_SetTimeouts(ftHandle, 3000, 3000);
   // Установка таймера задержки (latency timer):
   ftStatus |= FT_SetLatencyTimer(ftHandle, 1);
   // Сброс контроллера:
   ftStatus |= FT_SetBitMode(ftHandle, 0x0, 0x00);
   // Разрешить режим MPSSE:
   ftStatus |= FT_SetBitMode(ftHandle, 0x0, 0x02);
   if (ftStatus != FT_OK)
   {
      printf("fail on initialize FT2232H device ! \n");
      return false;
   }
   Sleep(50); // ожидание 50 мс, чтобы все железо USB было готово к работе

   //////////////////////////////////////////////////////////////////
   // Синхронизация интерфейса MPSSE отправкой "плохой" команды &xAA*
   //////////////////////////////////////////////////////////////////
   dwNumBytesToSend = 0;
   OutputBuffer[dwNumBytesToSend++] = '\xAA'; // добавление BAD command &xAA*
   // Отправка команд BAD:
   ftStatus = FT_Write(ftHandle, OutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0;   // очистка выходного буфера
   do
   {
      // Получение количества байт во входном буфере устройства:
      ftStatus = FT_GetQueueStatus(ftHandle, &dwNumInputBuffer);
      // Повторение цикла, пока не появятся данные или не произойдет таймаут:
   }while ((dwNumInputBuffer == 0) && (ftStatus == FT_OK));
   bool bCommandEchod = false;
   // Считывание данных из входного буфера:
   ftStatus = FT_Read(ftHandle, InputBuffer, dwNumInputBuffer, &dwNumBytesRead);
   for (dwCount = 0; dwCount < (dwNumBytesRead - 1); dwCount++)
   {
      // Проверка: принята ли команда Bad и эхо команды:
      if ((InputBuffer[dwCount] == BYTE('\xFA')) && (InputBuffer[dwCount+1] == BYTE('\xAA')))
      {
         bCommandEchod = true;
         break;
      }
   }
   if (bCommandEchod == false)
   {
      // Ошибка, не получилось принять эхо команды, сбой синхронизации
      // интерфейса MPSSE.
      printf("fail to synchronize MPSSE with command '0xAA' \n");
      return false;
   }
   
   //////////////////////////////////////////////////////////////////
   // Синхронизация интерфейса MPSSE отправкой "плохой" команды &xAB*
   //////////////////////////////////////////////////////////////////
   //dwNumBytesToSend = 0;  // очистка выходного буфера
   OutputBuffer[dwNumBytesToSend++] = '\xAB';   // добавление BAD command &xAB*
   // Отправка команд BAD:
   ftStatus = FT_Write(ftHandle, OutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0;   // очистка выходного буфера
   do
   {
      // Получение количества байт во входном буфере устройства:
      ftStatus = FT_GetQueueStatus(ftHandle, &dwNumInputBuffer);
      // Повторение цикла, пока не появятся данные или не произойдет таймаут:
   }while ((dwNumInputBuffer == 0) && (ftStatus == FT_OK));
   bCommandEchod = false;
   // Считывание данных из входного буфера:
   ftStatus = FT_Read(ftHandle, InputBuffer, dwNumInputBuffer, &dwNumBytesRead);
   for (dwCount = 0;dwCount < (dwNumBytesRead - 1); dwCount++)
   {
      // Проверка: принята ли команда Bad и эхо команды:
      if ((InputBuffer[dwCount] == BYTE('\xFA')) && (InputBuffer[dwCount+1] == BYTE( '\xAB')))
      {
         bCommandEchod = true;
         break;
      }
   }
   if (bCommandEchod == false)
   {
      // Ошибка, не получилось принять эхо команды, сбой синхронизации
      // интерфейса MPSSE.
      printf("fail to synchronize MPSSE with command '0xAB' \n");
      return false;
   }

   ////////////////////////////////////////////////////////////////////
   // Конфигурирование MPSSE для обмена с EEPROM через SPI
   ////////////////////////////////////////////////////////////////////
   // Запрет делителя тактов для master clock = 60 МГц:
   OutputBuffer[dwNumBytesToSend++] = '\x8A';
   // Выключение адаптивного тактирования
   OutputBuffer[dwNumBytesToSend++] = '\x97';
   // Запрет 3 phase data clock:
   OutputBuffer[dwNumBytesToSend++] = '\x8D';
   // Отправка подготовленных команд:
   ftStatus = FT_Write(ftHandle, OutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0;   //очистка выходного буфера
   // Команда для установки направлений младших 8 выводов,
   // чтобы настроить все биты как выходы:
   OutputBuffer[dwNumBytesToSend++] = '\x80';
    // Установка SDA, SCL в лог. 1, WP запрещен, SCLK, DO, GPIOL0 на бите &*:
   OutputBuffer[dwNumBytesToSend++] = '\x00';
   // Установка выводов SCLK, DO, GPIOL0 как выходов с битом **,
   // другие выводы как входы с битом &*
   OutputBuffer[dwNumBytesToSend++] = '\x0b';
   // Тактовая частота SCLK может быть установлена с делителем на 5 по формуле:
   // SCLK freq = 60 МГц /((1 + [(1 +ValueH*256) OR ValueL])*2)
   // Команда для установки делителя:
   OutputBuffer[dwNumBytesToSend++] = '\x86';
   // Установка ValueL (младший байт) делителя тактов:
   OutputBuffer[dwNumBytesToSend++] = BYTE(dwClockDivisor & '\xFF');
   // Установка ValueH (старший байт) делителя тактов:
   OutputBuffer[dwNumBytesToSend++] = BYTE(dwClockDivisor >> 8);
   // Отправка команд:
   ftStatus = FT_Write(ftHandle, OutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0;   // очистка выходного буфера
   Sleep(20);              // задержка
   // Выключение петли внутреннего зацикливания с выхода на вход (loop back).
   // Команда отключения loop back (соединения TDI - TDO):
   OutputBuffer[dwNumBytesToSend++] = '\x85';
   // Отправка команд:
   ftStatus = FT_Write(ftHandle, OutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0;   // очистка выходного буфера
   Sleep(30);              // задержка
   printf("SPI initial successful\n");
   return true;
}

// Эта подпрограмма используется для отправки одного слова данных

// с произвольным доступом по указанному адресу.
BOOL SPI_WriteByte2RandomAddr(FT_HANDLE ftHandle, WORD address,WORD bdata)
{
   dwNumBytesSent=0;
   SPI_CSEnable();
   // Отправка команды WRITE (запись):
   OutputBuffer[dwNumBytesToSend++] = MSB_FALLING_EDGE_CLOCK_BIT_OUT;
   OutputBuffer[dwNumBytesToSend++] = 2;
   OutputBuffer[dwNumBytesToSend++] = WRITE;
   // Отправка адреса:
   OutputBuffer[dwNumBytesToSend++] = MSB_FALLING_EDGE_CLOCK_BIT_OUT;
   OutputBuffer[dwNumBytesToSend++] = 7;
   OutputBuffer[dwNumBytesToSend++] = (BYTE)(address);
   // Отправка данных:
   OutputBuffer[dwNumBytesToSend++] = MSB_FALLING_EDGE_CLOCK_BYTE_OUT;
   OutputBuffer[dwNumBytesToSend++] = 1;
   OutputBuffer[dwNumBytesToSend++] = 0;  // длина данных 0x0001 означает, что будет
                                          // отправлено 2 байта данных
   OutputBuffer[dwNumBytesToSend++] = bdata >> 8;     // вывод старшего байта
   OutputBuffer[dwNumBytesToSend++] = bdata & 0xff;   // вывод младшего байта
   SPI_CSDisable();
   // Отправка команды MPSSE:
   ftStatus = FT_Write(ftHandle, OutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0;   // очистка выходного буфера
   return ftStatus;
}

// Эта подпрограмма используется для чтения одного слова данных

// с произвольным доступом по указанному адресу:
BOOL SPI_ReadByteRandomAddr(FT_HANDLE ftHandle, WORD address, WORD* bdata)
{
   dwNumBytesSent=0;
   SPI_CSEnable();
   // Отправка команды READ (чтение):
   OutputBuffer[dwNumBytesToSend++] = MSB_FALLING_EDGE_CLOCK_BIT_OUT;
   OutputBuffer[dwNumBytesToSend++] = 2;
   OutputBuffer[dwNumBytesToSend++] = READ;
   // Отправка адреса:
   OutputBuffer[dwNumBytesToSend++] = MSB_FALLING_EDGE_CLOCK_BIT_OUT;
   OutputBuffer[dwNumBytesToSend++] = 7;
   OutputBuffer[dwNumBytesToSend++] = (BYTE)(address);
   // Чтение данных:
   OutputBuffer[dwNumBytesToSend++] = MSB_FALLING_EDGE_CLOCK_BYTE_IN;
   OutputBuffer[dwNumBytesToSend++] = '\x01';
   OutputBuffer[dwNumBytesToSend++] = '\x00';   // длина данных 0x0001 означает,
                                                // что будет вдвигаться 2 байта
   SPI_CSDisable();
   // Отправка команды MPSSE:
   ftStatus = FT_Write(ftHandle, OutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
   dwNumBytesToSend = 0;   // очистка выходного буфера
   // Чтение 2 байт из буфера приема устройства:
   ftStatus = FT_Read(ftHandle, InputBuffer, 2, &dwNumBytesRead);
   *bdata = (InputBuffer[0] < < 8) + InputBuffer[1];
   return ftStatus;
}

int _tmain(int argc, _TCHAR* argv[])
{
   FT_HANDLE ftdiHandle;
   DWORD numDevs;
   FT_DEVICE_LIST_INFO_NODE *devInfo;
   ftStatus = FT_CreateDeviceInfoList(&numDevs);
   if (ftStatus == FT_OK)
      printf("Number of devices is %d\n",numDevs);
   else
      return 1;
   if (numDevs > 0)
   {
      // Выделение памяти под хранилище списка на основании
      // количества устройств numDevs:
      devInfo = (FT_DEVICE_LIST_INFO_NODE*)malloc(sizeof(FT_DEVICE_LIST_INFO_NODE)*numDevs);
      // Получение списка информации об устройствах:
      ftStatus = FT_GetDeviceInfoList(devInfo,&numDevs);
      if (ftStatus == FT_OK)
      {
         for (i = 0; i < numDevs; i++)
         {
            printf("Dev %d:\n",i);
            printf(" Flags=0x%x\n",devInfo[i].Flags);
            printf(" Type=0x%x\n",devInfo[i].Type);
            printf(" ID=0x%x\n",devInfo[i].ID);
            printf(" LocId=0x%x\n",devInfo[i].LocId);
            printf(" SerialNumber=%s\n",devInfo[i].SerialNumber);
            printf(" Description=%s\n",devInfo[i].Description);
            printf(" ftHandle=0x%x\n",devInfo[i].ftHandle);
         }
      }
   }
   else
      return 1;
   ftStatus = FT_Open(0,&ftdiHandle);
   if (ftStatus != FT_OK)
   {
      printf("Can't open FT2232H device! \n");
      return 1;
   }
   else
   {
      // Порт устройства был успешно открыт.
      printf("Successfully open FT2232H device! \n");
   }
   if(SPI_Initial(ftdiHandle) == TRUE)
   {
      byte ReadByte = 0;
      // Инициализация выходного буфера:
      for(i=0; i < MemSize; i++)
         DataOutBuffer[i] = i;
      // Первоначальная очистка буфера приема USB перед операцией чтения.
      // Получение количества байт в буфере приема устройства:
      ftStatus = FT_GetQueueStatus(ftdiHandle, &dwNumInputBuffer);
      if ((ftStatus == FT_OK) && (dwNumInputBuffer > 0))
      {
         // Чтение всех байт из буфера приема:
         FT_Read(ftdiHandle, InputBuffer, dwNumInputBuffer, &dwNumBytesRead);
      }
      WriteEECmd(ftdiHandle, WREN);
      WriteEECmd(ftdiHandle, ERAL);
      Sleep(20);
      for(i=0; i < MemSize; i++)
      {
         SPI_WriteByte2RandomAddr(ftdiHandle, i,DataOutBuffer[i]);
         Sleep(2);
         printf("Write data %d to address %d\n",DataOutBuffer[i],i);
      }
      Sleep(20);
      for(i=0; i < MemSize; i++)
      {
         SPI_ReadByteRandomAddr(ftdiHandle, i,&DataInBuffer[i]);
         printf("Read data from address %d = %d\n",i,DataInBuffer[i]);
      }
      getchar();  // ожидать нажатия клавиши пользователем...
   }
   FT_Close(ftdiHandle);
   return 0;
}