Libusb usb_bulk_read "echtzeitfähig"?

Hallo,

ich versuche mit der usb_bulk_read Funktion von libusb Daten auf meinen 
Rechner von einem USB-Controller zu übertragen.
Der Transfer funktioniert zwar, jedoch scheint es so, als ob die 
Usb_bulk_read funktion nicht wieder schnell genug aufgerufen wird, da 
Daten (welche kontinulierlich vom Controller versendet werden) zwischen 
dem mehrmaligen aufrufen verloren gehen.(also ein Neuaufruf immer wenn 
das Buffer-Array voll ist).
Macht man das Array jedoch "unendlich " groß gehen während dem Lesen der 
64Byte Blöcke vom Controller keine Daten verloren - an Bandbreite kann 
es also nicht mangeln.

Daher meine Frage: Ist diese Funktion überhaupt geeignet um eine quasi 
Echtzeitkommunikation zu ermöglichen (der Endpoint sollte alle 128µs 
voll sein).
Falls nicht, gibt es andere freie Bibliotheken?



Anbei der Quellcode (Ein Thread holt die Daten, der andere Schreibt sie 
in ein Datei.

//SOURCE CODE


#include <time.h>
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <windows.h>
#include "usb.h"




#define AVR_VID 0x03eb
#define AVR_PID 0x2022
#define EP_IN 0x81   //in Firmware definiert
#define EP_OUT 0x02 //in Firmware definiert

#define BUF_SIZE 64*16
#define BUF_IN_SIZE 64*8

FILE *datei;
static  char wert[BUF_SIZE];
static  char *pread=wert;
static  char *pwrite=wert;
static  char *start=wert;
 int byteread=0;
 int bytewritten=0;
 int durch1=0;
 float durch2=0;
int w1=0;
clock_t clock();
long t1=clock();
long t2=clock();
long t3=clock();

static int count=0;


DWORD thread0id=0;
DWORD thread1id=1;

static HANDLE  hThread[2];

CRITICAL_SECTION cs;



usb_dev_handle *open_dev(void)
{
  struct usb_bus *bus;
  struct usb_device *dev;

  for(bus = usb_get_busses(); bus; bus = bus->next)   //alle vorhandenn 
Busse durchgehen...
    {
      for(dev = bus->devices; dev; dev = dev->next)   //alle Geräte 
durchgehen...
        {
          if(dev->descriptor.idVendor == AVR_VID      //überprüfe 
aktuelles Gerät unserer VID/PID entspricht
             && dev->descriptor.idProduct == AVR_PID)
            {
              return usb_open(dev);                   //Gerät öffnen 
falls erfolgreich
            }
        }
    }
  return NULL;
}




DWORD WINAPI readthread(LPVOID lpParam)
{
     int i;
  usb_dev_handle *dev = NULL;
  usb_init();
  usb_find_busses();
  usb_find_devices();




  if(!(dev = open_dev()))                   //überprüfen ob Gerät 
gefunden wurde

      {printf(">> AVR USB KEY nicht gefunden\n\n");
      system("PAUSE");
      return 0;
      }
    else {printf(">> AVR USB KEY gefunden\n\n");}



  if(usb_set_configuration(dev, 1) < 0)  //1. Konfiguration auswählen 
(gibt nur 0 bei erfolg zurück, sonst <0,  hier nur eine Konfiguration
    {
      printf(">> error: Konfiguration konnte nicht geladen werden\n\n");
      usb_close(dev);
      system("PAUSE");
      return 0;
    }

  if(usb_claim_interface(dev, 0) < 0)
    {
      printf(">> error: Interface 0 anfordern fehlgeschlagen\n\n");
      usb_close(dev);
      system("PAUSE");
      return 0;
    }


while(1)
{

       durch1++;
       int byte_empfangen;
       char buffer_in[BUF_IN_SIZE];
       usb_bulk_read(dev, EP_IN, buffer_in, sizeof(buffer_in),20);

      if ((byte_empfangen)!= sizeof(buffer_in))
         {
          printf(">> error: bulk read timeout\n Error: returned: 
%i\n",byte_empfangen);
          system("PAUSE");
          return 0;
         }
*/

EnterCriticalSection(&cs);
         memcpy(pread,buffer_in,BUF_IN_SIZE);
LeaveCriticalSection(&cs);
        free(buffer_in);
         if ((pread-start) >= BUF_SIZE)
         {
EnterCriticalSection(&cs);
         pread=start; // Falls Buffer voll -> von Anfang an beschreiben
LeaveCriticalSection(&cs);
         }
         else
         {
EnterCriticalSection(&cs);
          pread+=BUF_IN_SIZE; //Lesezeiger verschieben
LeaveCriticalSection(&cs);
          byteread+=BUF_IN_SIZE;
         }

         if ( (pread+64)==pwrite )
         {    printf("Buffer überschrieben! !");
         }


 }
 return 1;
}


DWORD WINAPI writethread(LPVOID lpParam)
{


     int i=0;
     int tmp,tmp2;
while(1)
  {
durch2++;


      if(pread!=pwrite)
        {
         if ( (pwrite-wert)>=BUF_SIZE)
              {
EnterCriticalSection(&cs);
               pwrite=start;
LeaveCriticalSection(&cs);
              }
         else
         { //Anschlüsse auf Board verkehrt herum -> Wert drehen
                        tmp=0x00;
                        tmp|=0x80&( (*pwrite)<<7);
                      tmp|=0x40&( (*pwrite)<<5);
                      tmp|=0x20&( (*pwrite)<<3);
                      tmp|=0x10&( (*pwrite)<<1);
                      tmp|=0x08&( (*pwrite)>>1);
                      tmp|=0x04&( (*pwrite)>>3);
                      tmp|=0x02&( (*pwrite)>>5);
                      tmp|=0x01&( (*pwrite)>>7);
EnterCriticalSection(&cs);
                        pwrite++;
LeaveCriticalSection(&cs);
                        tmp|=(*pwrite<<8);
                        if(i>=64) {i=0;}

                    // 
fprintf(datei,"%i:\t%i\t%i\n",i,tmp,tmp-tmp2-1);
                      // fprintf(datei,"%i\n",tmp);

                        i++;
                        bytewritten+=2;
EnterCriticalSection(&cs);
                        pwrite++;
LeaveCriticalSection(&cs);

                       fprintf(datei,"%i",tmp);
                                               tmp2=tmp;
          }


       }

}

  return 0;

}



int main(void)
{

datei=fopen("daten.txt","w+");
if (!InitializeCriticalSectionAndSpinCount(&cs,0x80000400) ) return 0;
hThread[0]=CreateThread(NULL,0,readthread,0,0,&thread0id);
hThread[1]=CreateThread(NULL,0,writethread,0,0,&thread1id);
SetThreadPriority(hThread[0], 31) 
;
WaitForMultipleObjects(2,hThread,TRUE,2000);
CloseHandle(hThread[0]);
CloseHandle(hThread[1]);
DeleteCriticalSection(&cs);
if (fclose(datei)!=0) printf("Fehler fclose()");






  return 0;
}