#include <rtdx.h>
#include <stdlib.h>

// declare a global RTDX channel
RTDX_CreateOutputChannel( ochanData );
RTDX_CreateInputChannel( ichanInfo );

//Packet size and RTDX data bufer
#define RTDX_PACKET_SIZE 512
static char vBuf[RTDX_PACKET_SIZE];

int main()
{
    unsigned int i, returncode, received;

    //Set rtdx bufer data
    for (i=0; i<RTDX_PACKET_SIZE; i++) vBuf[i]=rand()%256;

    // enable the output channel
    RTDX_enableOutput( &ochanData );

    // enable the input channel
    RTDX_enableInput( &ichanInfo );

    // Ожидание от host-PC значения кол-ва пересылаемых пакетов
    do {
        returncode = RTDX_read( &ichanInfo, &received, 4);
    } while((returncode==0)||(received==0));

    //send data to host
    for (i=0; i<1000; i++)
    {
        // make sure writes go through
        while(RTDX_write( &ochanData, vBuf, RTDX_PACKET_SIZE )==0);
        // check if RTDX channel is ready
        while ( RTDX_writing != NULL );
    }

    // disable the input channel
    RTDX_disableInput( &ichanInfo );

    // disable the output channel
    RTDX_disableOutput( &ochanData );

    return 1;
}

#include "stdafx.h"

// ########## RTDX(TM) ##########
#import "rtdxint.dll"
using namespace RTDXINTLib;
// ########## RTDX(TM) ##########
#include <iostream.h>
#include <stdio.h>
#include <fstream>            // For fstream
//Количество считываемых данных=RTDX_PACKET_NUMB*RTDX_PACKET_SIZE
#define RTDX_PACKET_SIZE 512
#define RTDX_PACKET_NUMB 1000
//Размер буфера данных
#define RTDX_DATA_SIZE  (RTDX_PACKET_NUMB*RTDX_PACKET_SIZE)


int _tmain(int argc, _TCHAR* argv[])
{
    HRESULT hr, Result = NO_ERROR;
    long status=Success, status_of_write;
    VARIANT sa;
    IRtdxExpPtr DataChannel;
    IRtdxExpPtr H2TInfoChannel;

    // Initialize COM
    ::CoInitialize( NULL );

    // Initialize VARIANT
    ::VariantInit(&sa);

    // Instantiate the RTDX COM Objects
    hr = DataChannel.CreateInstance(__uuidof(RTDXINTLib::RtdxExp) /*L"RTDX"*/ );
    if ( FAILED(hr) ) {
        printf("RTDX Channel Instantiation failed!\n");
        Result = E_FAIL;
        goto ExitProc;
    }
    hr = H2TInfoChannel.CreateInstance(__uuidof(RTDXINTLib::RtdxExp) /*L"RTDX"*/ );
    if ( FAILED(hr) ) {
        printf("RTDX Channel Instantiation failed!\n");
        Result = E_FAIL;
        goto ExitProc;
    }

    //Opening RTDX Channels
    printf("Opening RTDX Channels...\n");
    if (DataChannel->Open( "ochanData", "R" ) != Success)
    {
        printf("RTDX Channel Open for reading failed!\n");
        Result = E_FAIL;
        goto ExitProc;
    }
    if (H2TInfoChannel->Open( "ichanInfo", "W" ) != Success)
    {
        printf("RTDX Channel Open for writing failed!\n");
        Result = E_FAIL;
        goto ExitProc;
    }

    // Отсылка стартового кода для начала пересылки пакета
    int CountPacket = RTDX_PACKET_NUMB;
    do {
        status = H2TInfoChannel->WriteI4(CountPacket, &status_of_write);
    }while(status != Success);

    //Приём данных с измерением времени
    int CountByte = 0;

    DWORD dwStart = GetTickCount();
    while(CountByte < RTDX_DATA_SIZE)
    {
        //Чтение сообщения
        status = DataChannel->ReadSAI1( &sa );
        switch(status)
        {
            case Success:
            {
                if (status==Success)
                {
                    //Обработка текущего пакета
                    int dataNumb = sa.parray->rgsabound[0].cElements;
                    if ( (dataNumb<=0) ) {
                        printf("RTDX Data Channel Zero length message received!\n");
                        Result = E_FAIL;
                        goto ExitProc;
                    }
                    //Обновление счётчика кол-ва пакетов
                    CountPacket--;
                    //Обновление счётчика принятых байт
                    CountByte += dataNumb;
                    //Вывод кол-ва принятых байт на экран
                    printf("Quantity accepted bytes=%i\r", CountByte);
                }
                break;
            }
            case ENoDataAvailable:
            {
                //delay for a while
                Sleep(1);
                break;
            }
            default:
            {
                Result = E_FAIL;
                goto ExitProc;
            }
        }
    }
    DWORD dwEnd = GetTickCount();
    double Rate=(double)(RTDX_DATA_SIZE*8000.)/(double)(dwEnd-dwStart);
    printf("Rate=%f MBit/sec\n", Rate/(1024.*1024.));

ExitProc:
    // Close chanels
    DataChannel->Close();
    H2TInfoChannel->Close();

    // Release chanels
    DataChannel.Release();
    H2TInfoChannel.Release();

    // Clear VARIANT
    ::VariantClear(&sa);

    // Uninitialize COM
    ::CoUninitialize();

    return 0;
}