VUSB Long Transfers Test

[R. B. (dxx255)]

Hallo,
Ich habe versucht, Datenübertragungen von 1024 Bytes mittels VUSB 
zwischen einem Ubuntu-PC und einem ATMEGA328p zu realisieren. Nur aus 
irgendeinem mir nicht ersichtlichen Grund funktioniert dieses einfache 
Bsp nicht.
Könnte mir jemand sagen wo mein Fehler liegt?
Danke im Voraus
Folgender Code(µC):

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/wdt.h>
#include <stdlib.h>
#include "usbdrv.h"
#define F_CPU 16000000L
#include <util/delay.h>
#define USB_PC_IN 0
#define USB_PC_OUT 1
static uchar buf[1024];
static unsigned int dataReceived = 0, dataLength = 0;
unsigned int i=0;
USB_PUBLIC uchar usbFunctionWrite(uchar *data, uchar len) {
                    
    for(i = 0; dataReceived < dataLength && i < len; i++, dataReceived++)
        buf[dataReceived] = data[i];
    return (dataReceived == dataLength); // 1 if we received it all, 0 if not
}
USB_PUBLIC usbMsgLen_t usbFunctionSetup(uchar data[8]) {
    usbRequest_t *rq = (void *)data; // cast data to correct type
        
    switch(rq->bRequest) { // custom command is in the bRequest field
    case USB_PC_IN: // send data to PC
  { 
       usbMsgLen_t len = sizeof(buf);             // we return up to 1024 bytes
        if(len > rq->wLength.word)          // if the host requests less than we have
            len = rq->wLength.word;         // return only the amount requested
        usbMsgPtr = buf;                 // tell driver where the buffer starts
        return len;
  }
    case USB_PC_OUT: // receive data from PC
        dataLength = (uchar)rq->wLength.word;
        dataReceived = 0;
        if(dataLength > sizeof(buf)) // limit to buffer size
            dataLength = sizeof(buf);
                        
        return USB_NO_MSG; // usbFunctionWrite will be called now
    }

    return 0; // should not get here

}

int main() {
       wdt_enable(WDTO_1S); // enable 1s watchdog timer
      usbInit();
      usbDeviceDisconnect(); // enforce re-enumeration
      for(i = 0; i<250; i++) { // wait 500 ms
          wdt_reset(); // keep the watchdog happy
          _delay_ms(2);
      }
      usbDeviceConnect();
        
      sei(); // Enable interrupts after re-enumeration
        
      while(1) {
          wdt_reset(); // keep the watchdog happy
          usbPoll();
      }
        
      return 0;
}

Code PC-Seite:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <usb.h>
#define USB_PC_IN 0
#define USB_PC_OUT 1
#include "usb_help.c"
int main(int argc, char **argv) {
      usb_dev_handle *handle = NULL;
    
      int i = 0;
      char buffer[1024];
  char retBuf[1024];
  for(i;i<1024;i++){
    buffer[i]=(char)i%128;
  }
      handle = usbOpenDevice(0x16C0, "vendor", 0x05DC, "product");
      if(handle == NULL) {
          fprintf(stderr, "Could not find USB device!\n");
          exit(1);
      }
  i = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT, USB_PC_OUT, 0, 0, (char *)buffer, 1024, 5000);
  i = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, USB_PC_IN, 0, 0, (char *)retBuf, 1024, 5000);
    if(i < 0)
        fprintf(stderr, "USB error: %s\n", usb_strerror());
  for(i=0;i<1024;i++){
    if(buffer[i]!=retBuf[i]){
      printf("Error: Unvollständige Übertragung!i:%d\n",i);break;
    }
  }
  
    usb_close(handle);
    return 0;
}

P.S.: Der PC gibt "Error: Unvollständige Übertragung!i:1" aus

[R. B. (dxx255)]

Es muss aber ein Softwarefehler sein, da die Hardware mit anderen 
Programmen funktioniert

[Easylife (Gast)]

Die Größe von Endpoint 0 ist limitiert auf 64 Bytes.
D.h. 1024 bytes werden in 16 "short-packets" übertragen.

Gut möglich, dass deine Funktionen hardwareseitig oder host-seitig die 
short packets nicht automatisch handeln, und du dich selbst drum kümmern 
musst.
Da 1024/64 genau 16 sind, muss als 17. packet ein packet mit 0 byte 
größe übertragen werden.

Hast du einen USB Analyzer mit dem du dir angucken kannst, was auf dem 
Bus tatsächlich übertragen wird?

Wenn du größere Datenmengen schnell übertragen willst, benötigst du für 
jede Richtung einen extra Endpoint (bulk oder isochronous). Die können 
mehr als 64 bytes in einem Paket.

[R. B. (dxx255)]

Nein ich habe leider keinen solchen Analyzer. Wie definiere ich einen 
extra Endpoint? Und welche Art wäre besser? Ist das mit VUSB überhaupt 
möglich?

[Detlef K. (adenin)]

Mit Wireshake hat man auch unter Linux einen guten USB-Analyser.
Wen noch nicht geladen, dann vorher das Modul usbmon laden.

sudo modprobe usbmon

http://wiki.wireshark.org/CaptureSetup/USB#Linux

[Easylife (Gast)]

Roman B. schrieb:
> Nein ich habe leider keinen solchen Analyzer. Wie definiere ich einen
> extra Endpoint?

Dazu muss der Devicedescriptor des Gerätes entsprechend erweitert 
werden.

> Und welche Art wäre besser?

Isochronous nimmt man z.B. für Streaming (z.B. Audio), für das auf dem 
Bus eine feste Bandbreite reserviert wird. Es gibt aber kein 
Error-Handling. Kaputte Pakete werden verworfen.

Bulk für alles andere (Mass Storage etc.).

Ist das mit VUSB überhaupt
> möglich?

Weiss ich nicht.

Mal anders herum gefragt:
Welche Datenmenge willst du denn pro Sekunde übertragen.
Evtl. reicht Endpoint 0 mit short packets ja auch aus.

[R. B. (dxx255)]

Ich will nur 1024 Bytes hin und wieder zurück schicken.

[holger (Gast)]

>Ich will nur 1024 Bytes hin und wieder zurück schicken.

Dann wirst du das wohl in mehreren kleineren Häppchen tun müssen.

[easylife (Gast)]

Roman B. schrieb:
> Ich will nur 1024 Bytes hin und wieder zurück schicken.

das geht, eben in 64 byte happen. und davon gehen max. 1000 stueck pro 
sek.
wenn das reicht, machs ueber ep0.

du musst rausfinden, ob deine funktionen ein grosses paket automatisch 
zerlegen/zusammensetzen. ansonsten musst du das von hand prigrammieren.

[Frank K. (fchk)]

VUSB ist ja grundsätzlich Low Speed. Und für Low Speed Devices gilt, 
dass Datenpakete maximal 8 Bytes groß sein dürfen. Bei Full Speed sind 
64 Byte Pakete erlaubt. Siehe USB 2.0 Standard, Kapitel 8, Abschnitt 
8.4.4 "Data Packets".

Außerdem kannst Du nur Control und Interrupt Transfers zu einem Low 
Speed Device durchführen, Bulk Transfers erlaubt der USB 2.0 Standard 
nicht. Siehe USB 2.0 Standard, Kapitel 5, Abschnitt 5.8.3 "Bulk Transfer 
Packet Size Constraints": "A low-speed device must not have bulk 
endpoints."

Also bleibe bei Control Transfers, spalte Dein Kilobyte in 8-Byte 
Päckchen und verschicke die.

Wenn Du mit dieser Lösung unzufrieden bist, dann musst Du halt einen 
richtigen USB-Controller verwenden, der Full-Speed USB in Hardware 
macht. Das ist dann auch wirklich USB 2.0 Standard-konform.

fchk

[R. B. (dxx255)]

Funktioniert doch nicht:(
Ich werde es einfach mittels mehrerer control-Übertragungen realisieren.

Danke trotzdem:)

[easylife (Gast)]

vusb=low speed?! das ist ja wirklich mist. 8 bytes ist ja nichts. hast 
du keine moeglichkeit wenigstens full-speed zu nutzen?

[R. B. (dxx255)]

Nein, hab leider keinen Hardware-USB-Controller:( Macht aber nix - hab 
zwei Funktionen geschrieben die den Datentransfer in 128 Byte Blöcken 
übernehmen! Das klappt einwandfrei:) Nur mehr als 254 Byte kann ich 
nicht auf einmal transferieren (auch mit USB_CFG_LONG_TRANSFERS=1 
nicht)- daher die 128 Byte Blöcke.

Ich persönlich finde VUSB echt gut weil man mithilfe von 5 
"Standard-Bauteilen" (3 Widerstände, 2 Zener-Dioden) einen AVR über USB 
kommunizieren lassen kann. Man muss sich halt manchmal softwaretechnisch 
etwas behelfen aber sonst klappt´s (bei mir zumindest) einwandfrei 
(obwohl ich mich mit USB nicht besonders gut auskenne - mehr als 
control-transfers bring ich nicht zustande).

Danke für die Hilfe - Problem gelöst

P.S.: Danke für den Tipp mit Wireshark als USB Analyzer