Subversion Repositories usb_ft232h_avalon-mm_interface

#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <cmath>
#include <limits>
#include <chrono>
#include <unistd.h>
 
#include "ftd2xx.h"
 
 
using namespace std;
 
 
const int DEV_TYPE = 8;
const int DEV_VID = 0x0403;
const int DEV_PID = 0x75D8;
const int DEV_ID = (DEV_VID << 16) | DEV_PID;
 
const int BUFFER_SIZE = 524288;
const int MAX_TRANSACTION_SIZE = 65536 * 2;
 
 
enum TestMode {
    TM_READ = 1,
    TM_ECHO
};
 
 
FT_HANDLE ftHandle = 0;
FT_STATUS ftStatus = 0;
 
vector<int> devList;
 
uint8_t rxBuffer[BUFFER_SIZE] = {0};
uint8_t txBuffer[BUFFER_SIZE] = {0};
int txBufferHead = 0;
int rxBufferTail = 0;
 
DWORD readedBytesCount = 0;
DWORD writtenBytesCount = 0;
DWORD lastPortionSize = 0;
int errorsCount = 0;
 
DWORD targetSize = 524288 * 100;//262144;//524288;
int iterationCount = 5;
 
//DWORD startTime = 0, currentTime = 0, prevTime = 0;
double maxSpeed = 0, avgSpeed = 0, currentSpeed = 0;
double minSpeed = std::numeric_limits<DWORD>::max();
 
chrono::steady_clock::time_point timeBegin, timeCurrent, timePrev;
 
 
vector<int> errorsVector;
 
 
 
inline
void findDevice()
{
#ifdef linux
    ftStatus = FT_SetVIDPID(0x0403, 0x75d8);
#endif
    DWORD devCount = 0;
    devList.clear();
    ftStatus = FT_CreateDeviceInfoList(&devCount);
    if (!devCount)
        return;
    FT_DEVICE_LIST_INFO_NODE *ftDevInfo =
            (FT_DEVICE_LIST_INFO_NODE*)malloc(sizeof(FT_DEVICE_LIST_INFO_NODE)*devCount);
    FT_GetDeviceInfoList(ftDevInfo, &devCount);
    for (uint32_t i = 0; i < devCount; ++i) {
        if (ftDevInfo[i].ID == DEV_ID) {
            devList.push_back(i);
            cout << "Dev flags: " << ftDevInfo[i].Flags << endl;
        }
    }
    free(ftDevInfo);
}
 
inline
bool openDevice(int index)
{
    ftStatus = FT_Open(index, &ftHandle);
    if (!FT_SUCCESS(ftStatus)) {
        cout << "Unable to open USB device. " << ftStatus << endl;
        return false;
    }
    if (ftHandle == NULL) {
        cout << "No device found" << endl;
        return false;
    }
    //configure
    uint8_t mask=0xff, mode=0x0, latency=2;
    mode = 0x0; //reset mode
    ftStatus = FT_SetBitMode(ftHandle, mask, mode);
    usleep(1000000);
    mode = 0x40;
    ftStatus = FT_SetBitMode(ftHandle, mask, mode);
    if (!FT_SUCCESS(ftStatus)) {
        cout << "Set bit mode failed. " << ftStatus << endl;
        return false;
    }
    FT_SetLatencyTimer(ftHandle, latency);
    FT_SetUSBParameters(ftHandle, 0x10000, 0x10000);
    FT_SetFlowControl(ftHandle, FT_FLOW_RTS_CTS, 0x0, 0x0);
    FT_Purge(ftHandle, FT_PURGE_RX | FT_PURGE_TX);
    return true;
}
 
inline
void closeDevice()
{
    FT_Close(ftHandle);
}
 
 
inline
DWORD availableData()
{
    DWORD queue;
    ftStatus = FT_GetQueueStatus(ftHandle, &queue);
    if (!FT_SUCCESS(ftStatus)) {
        cout << "Get available data failed. " << ftStatus << endl;
        return 0;
    }
    return queue;
}
 
inline
bool readData(void *buffer, DWORD size, DWORD &bytesReaded)
{
    ftStatus = FT_Read(ftHandle, buffer, size, &bytesReaded);
    if (!FT_SUCCESS(ftStatus)) {
        cout << "Read data failed. " << ftStatus << endl;
        return false;
    }
    return true;
}
 
inline
bool writeData(void *data, DWORD size, DWORD &bytesWritten)
{
    ftStatus = FT_Write(ftHandle, data, size, &bytesWritten);
    if (!FT_SUCCESS(ftStatus)) {
        cout << "Write data failed. " << ftStatus << endl;
        return false;
    }
    return true;
}
 
 
void calcSpeed(bool force = false)
{
    timeCurrent = chrono::steady_clock::now();
    double time = chrono::duration_cast<chrono::milliseconds>(timeCurrent - timePrev).count();
    if (( time >= 500 ) || force) {
        double dataSize = lastPortionSize * 1.0 / 1000;
        time /= 1000;
        currentSpeed = dataSize / time;
        dataSize = (readedBytesCount + writtenBytesCount) * 1.0 / 1000;
        time = chrono::duration_cast<chrono::milliseconds>(timeCurrent - timeBegin).count();
        time /= 1000;
        avgSpeed = dataSize / time;
        if (currentSpeed > maxSpeed)
            maxSpeed = currentSpeed;
        if (currentSpeed < minSpeed)
            minSpeed = currentSpeed;
        timePrev = timeCurrent;
        lastPortionSize = 0;
 
        cout << "Time: " << floor(time) << " Size(w/r): " << fixed << setprecision(3)
             << writtenBytesCount * 1.0 / 1000 << "/"
             << readedBytesCount * 1.0 / 1000 << defaultfloat
             << " kB \tRate (min/max/avg/current): " << int(floor(minSpeed)) << "/"
             << int(floor(maxSpeed)) << "/" << int(floor(avgSpeed)) << "/"
             << int(floor(currentSpeed)) << " kB/s \tErrors: " << errorsCount << endl;
        flush(cout);
    }
}
 
inline
void checkData(int offset, int size)
{
    for (int i = offset; (i < BUFFER_SIZE) && (i < offset + size); ++i) {
        if (rxBuffer[i] != txBuffer[i]) {
            if (errorsCount == 0) {
                int pi = i - 1;
                if (pi < 0)
                    pi = targetSize - 1;
                while (pi > BUFFER_SIZE) {
                    pi -= BUFFER_SIZE;
                }
                int ni = i + 1;
                if (ni >= BUFFER_SIZE)
                    ni = 0;
 
                cout << i << " " << int(txBuffer[i]) << " - " << int(rxBuffer[i])
                     << " \t" << pi << " " << int(txBuffer[pi]) << " - "
                     << int(rxBuffer[pi]) << " \t" << ni << " "
                     << int(txBuffer[ni]) << " I: ";
 
                /*for (int j = 0; (j < targetSize) && (j < BUFFER_SIZE); ++j) {
                    if (txBuffer[j] == rxBuffer[i]) {
//                        cout << j << " ";
                        auto fit = find(begin(errorsVector), end(errorsVector), j);
                        if ( fit != errorsVector.end()) {
                            cout << j << " ";
                        }
                    }
                }*/
                cout << endl;
            }
            ++errorsCount;
        }
    }
}
 
 
inline
void readMode()
{
    DWORD available = 0;
    DWORD bytesRead = 0;
    uint8_t value = 0;
 
    readedBytesCount = 0;
    writtenBytesCount = 0;
    lastPortionSize = 0;
    txBufferHead = 0;
    rxBufferTail = 0;
    errorsCount = 0;
    maxSpeed = 0;
    minSpeed = std::numeric_limits<DWORD>::max();
    avgSpeed = 0;
    currentSpeed = 0;
 
    txBuffer[0] = TM_READ;
    if (!writeData(txBuffer, 1, bytesRead)) {
        return;
    }
    timePrev = timeCurrent = timeBegin = chrono::steady_clock::now();
    while (true) {
        available = availableData();
        if (!available)
            continue;
        if (available > BUFFER_SIZE)
            available = BUFFER_SIZE;
        if (!readData(rxBuffer, available, bytesRead)) {
            return;
        }
        if (!bytesRead)
            continue;
        if (!readedBytesCount) {
            value = rxBuffer[0];
        }
        for (DWORD i = 0; i < bytesRead; ++i) {
            if (value != rxBuffer[i]) {
                ++errorsCount;
                value = rxBuffer[i];
            }
            ++value &= 0xFF;
        }
        readedBytesCount += bytesRead;
        lastPortionSize += bytesRead;
 
        calcSpeed();
    }
}
 
inline
void echoMode()
{
    DWORD available = 0;
    DWORD bytesRead = 0;
    DWORD bytesWrite = 0;
    DWORD writeSize = 0;
 
    readedBytesCount = 0;
    writtenBytesCount = 0;
    lastPortionSize = 0;
    txBufferHead = 0;
    rxBufferTail = 0;
    errorsCount = 0;
    maxSpeed = 0;
    minSpeed = std::numeric_limits<DWORD>::max();
    avgSpeed = 0;
    currentSpeed = 0;
 
    uint8_t mode = TM_ECHO;
    /*if (!writeData(&mode, 1, bytesRead)) {
        return;
    }
    if (!writeData(&targetSize, 4, bytesRead)) {
        return;
    }*/
 
//    prevTime = currentTime = startTime = GetTickCount();
    timePrev = timeCurrent = timeBegin = chrono::steady_clock::now();
 
    cout << "Start loop" << endl;
    while ((writtenBytesCount < targetSize) || (readedBytesCount < targetSize)) {
        // send
        if ((writtenBytesCount < targetSize)
                && ((writtenBytesCount - readedBytesCount) < MAX_TRANSACTION_SIZE)) {
            writeSize = BUFFER_SIZE - txBufferHead;
            if (writeSize > (targetSize - writtenBytesCount))
                writeSize = targetSize - writtenBytesCount;
            if (writeSize > MAX_TRANSACTION_SIZE)
                writeSize = MAX_TRANSACTION_SIZE;
            if (!writeData(&txBuffer[txBufferHead], writeSize, bytesWrite)) {
                return;
            }
//            cout << "write " << txBufferHead << " " << int(txBuffer[txBufferHead])
//                 << " " << bytesWrite << endl;
            writtenBytesCount += bytesWrite;
            lastPortionSize += bytesWrite;
            txBufferHead += bytesWrite;
            if (txBufferHead == BUFFER_SIZE) {
                txBufferHead = 0;
            }
            else if (txBufferHead > BUFFER_SIZE) {
                cout << "Tx buffer range error" << endl;
                return;
            }
        }
 
        // read
        available = availableData();
        if ((readedBytesCount < targetSize) && available) {
            if (available > (BUFFER_SIZE - rxBufferTail))
                available = BUFFER_SIZE - rxBufferTail;
            if (available > (targetSize - readedBytesCount)) {
                cout << "More data then need " << available << "/"
                     << targetSize - readedBytesCount << endl;
                available = targetSize - readedBytesCount;
            }
            if (!readData(&rxBuffer[rxBufferTail], available, bytesRead)) {
                return;
            }
//            cout << "read " << rxBufferTail << " " << bytesRead
//                 << " " << rxBufferTail + bytesRead << endl;
            readedBytesCount += bytesRead;
            lastPortionSize += bytesRead;
            checkData(rxBufferTail, bytesRead);
            rxBufferTail += bytesRead;
            if (rxBufferTail == BUFFER_SIZE) {
                rxBufferTail = 0;
            }
            else if (rxBufferTail > BUFFER_SIZE) {
                cout << "Rx buffer range error" << endl;
                return;
            }
        }
 
        calcSpeed();
    }
    calcSpeed(true);
    cout << endl << availableData() << endl;
}
 
 
int main(int argc, char *argv[])
{
    cout << "Hello World!" << endl;
 
    for (int i = 0; i < BUFFER_SIZE; ++i) {
        txBuffer[i] = rand() & 0xFF;
        if (txBuffer[i] == 94) {
            errorsVector.push_back(i);
            --i;
        }
    }
 
    findDevice();
    cout << devList.size() << " devices found" << endl;
    if (!devList.size())
        return 0;
    DWORD index;
    cout << "Put device index (from 0 to devices count): ";
    cin >> index;
    cout << endl;
    if (index >= devList.size()) {
        cout << "You fool!" << endl;
        return 0;
    }
    cout << "Open device " << index << " ... ";
    if (!openDevice(index)) {
        cout << "[FAIL]" << endl;
        return 0;
    }
    cout << "[ OK ]" << endl;
 
    cout << "Select mode:\n\t" << TM_READ << " - read\n\t"
         << TM_ECHO << " - echo\n\t* - exit" << endl;
    cout<< "Enter your choice: ";
    cin >> index;
    cout << endl;
    switch (index) {
    case TM_READ:
        cout << "Start read mode" << endl;
        readMode();
        break;
    case TM_ECHO:
        cout << "Start echo mode" << endl;
        while (iterationCount-- && (errorsCount == 0)) {
            echoMode();
//            cout << "Data:" << endl;
//            for (int i = 0; i < targetSize; ++i) {
//                cout << int(txBuffer[i]) << " = " << int(rxBuffer[i]) << endl;
//            }
//            ++targetSize;
        }
        break;
    default:
        break;
    }
 
    closeDevice();
    cout << "Finish" << endl;
    return 0;
}