LibUSB <- PIC usb_bulk_read liefert keine Daten

[Dirk F. (sensornix)]

Hallo

Ich versuche gerade eine USB-Kommunikation mit einem PIC18F2550 zm 
laufen zu bringen. PIC seitig basierend auf mit dem Microchip USB-Stack 
v.2.3a.
Auf dem PC verwende ich LibUSB-Win32 (libusb-win32-device-bin-0.1.12.1).
Compiliert wird mit C18 für den PIC und mit MinGW für die PC-Anwendung.

Die Zeile

bytesread1=usb_bulk_read(dev, 0x81, (char*)&tmp1[0], 64, 5000);

empfängt die richtige Anzahl von Bytes.
Leider sind die "empfangenen?" Daten in tmp1 immer null.

Gesendet wird der Wert 70.

Vielleicht hat jemand eine Idee?

Hier der Output

Warte auf Taste 's'
s
Taste 's' gedr³ckt
Geschrieben s

: Gelesen EP1           : 000000  : Bytes = 6

Gelesen EP1     : 000  : Bytes = 3

Gelesen EP1     : 000  : Bytes = 3

Gelesen EP1     : 000  : Bytes = 3

Gelesen EP1     : 000  : Bytes = 3

Gelesen EP1     : 000  : Bytes = 3

Gelesen EP1     : 000  : Bytes = 3

Gelesen EP1     : 000  : Bytes = 3

Gelesen EP1     : 000  : Bytes = 3


 ENDE

Hier der Quellcode der Windowsanwendung und ein Auszug aus der Firmware.

 
#include <windows.h>
#include <process.h> /* _beginthread, _endthread */
#include <stddef.h>
#include <stdlib.h>
#include <conio.h>
#include <E:\Projekte\Kamera_Sonde\Kameramodul_Pic_USB\libusb-win32-device-bin-0.1.12.1\include\usb.h>


#define USB_DEBUG 2

/* the device's vendor and product id */
#define MY_VID 0x1234
#define MY_PID 0x5678

/* the device's endpoints */
#define EP1_IN 0x81
#define EP1_OUT 0x01
#define EP2_IN 0x82
#define EP2_OUT 0x02


#define BUF_SIZE (64)

usb_dev_handle *dev = NULL; /* the device handle */

char tmp[BUF_SIZE];
char tmp1[BUF_SIZE];
char tmp2[BUF_SIZE];

void *context1 = NULL;
void *context2 = NULL;

int bytesread1;
int bytesread2;

usb_dev_handle *open_dev(void);


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

  for(bus = usb_get_busses(); bus; bus = bus->next)
    {
    for(dev = bus->devices; dev; dev = dev->next)
      {
      if( (dev->descriptor.idVendor == MY_VID) && (dev->descriptor.idProduct == MY_PID) )
        { 
        printf("got it open\n\n");
        return usb_open(dev);
        }
      }
    }
  return NULL;
  }



int main(void)
  {
  usb_set_debug(255);

  int  i= 0;
  unsigned char j = 0;    // 48 -> 122

  usb_init(); /* initialize the library */
  usb_find_busses(); /* find all busses */
  usb_find_devices(); /* find all connected devices */

  i = 0;
  j= 48;
  
  while (i<BUF_SIZE-1)

    {
    tmp[i]  = 66;
    tmp1[i] = 66;
    tmp2[i] = 66;
    // printf("i = %i  \t tmp = %c \t tmp1 = %c \t tmp2 = %c \n", i, tmp[i], tmp1[i], tmp2[i]);
    i+=1;
    j+=1;
    if (j==123) j = 48;
    }
    tmp[BUF_SIZE-1]  = '\0';
    tmp1[BUF_SIZE-1] = '\0';
    tmp2[BUF_SIZE-1] = '\0';

  printf("\n");


  if(!(dev = open_dev()))
    {
    printf("error: device not found!\n");
    return 0;
    }

  if(usb_set_configuration(dev, 1) < 0)
    {
    printf("error: setting config 1 failed\n");
    usb_close(dev);
    return 0;
    }

  if(usb_claim_interface(dev, 0) < 0)
    {
    printf("error: claiming interface 0 failed\n");
    usb_close(dev);
    return 0;
    }



  char Taste;
  printf("Warte auf Taste 's'\n");
  while (Taste = getchar(), Taste == 's') ;
  printf("Taste 's' gedrückt\n");


    tmp[0]  = 's';

    int wrote;
    wrote=usb_bulk_write(dev, EP1_OUT, tmp, 1, 5000);

    if(wrote != 1)
      {
      printf("error: bulk write failed %d\n", wrote);
      }
    else
      {
      printf("Geschrieben %c \n\n: ", tmp[0]);
      }    

  for (j=1; j < 10; j++)
   {
   bytesread1=usb_bulk_read(dev, 0x81, (char*)&tmp1[0], 64, 5000);
   printf("Gelesen EP1   \t: ");
   for (i=0; i<bytesread1; i++) printf("%i", tmp1[i]);
   printf("  : Bytes = %d\n", bytesread1);
   puts(tmp1);
   }

  usb_release_interface(dev, 0);
  usb_close(dev);

  printf("\n ENDE \n");

  return 0;
  }

Firmwareauszug

#pragma udata USB_VARS_CONTROL      // RAM=usb5

  BYTE IN_Control[USB_Control_EP_SIZE];  // Puffergröße definiert in usb_config.h
  BYTE OUT_Control[USB_Control_EP_SIZE];

#define PUFFER_ANZAHL 4

#pragma udata USB_VARS_IN_DATA      // RAM=usb6 

  BYTE IN_Data [PUFFER_ANZAHL][USB_Data_EP_SIZE];    //  [PUFFER_ANZAHL] * [USB_Data_EP_SIZE] = 256 Bytes = 1 Bank

#pragma udata USB_VARS_OUT_DATA     //RAM=usb7

  BYTE OUT_Data [USB_Data_EP_SIZE];

#pragma udata

unsigned char IN_Data_Belegung[PUFFER_ANZAHL];
unsigned char IN_Control_Belegung;
unsigned char OUT_Control_Belegung;

#define RS232_sendbuffer_maxcount 32                    // Physikalische Puffergröße
BYTE  RS232_sendbuffer [RS232_sendbuffer_maxcount];  // Bytearray
BYTE  RS232_sendbuffer_count;


#define RS232_readbuffer_maxcount 256     // Physikalische Puffergröße
BYTE   *RS232_readbuffer = IN_Data;    // Bytearray
BYTE    RS232_readbuffer_count;

unsigned char Sende_USB;
unsigned char puffer_akt;
unsigned short long Bildlaenge;
BYTE puffererror;
BYTE CAM_Status;


USB_HANDLE USB_Control_Out_Handle = 0;
USB_HANDLE USB_Control_In_Handle = 0;
USB_HANDLE USB_Data_In_Handle = 0;
USB_HANDLE USB_Data_Out_Handle = 0;


/** PRIVATE PROTOTYPES *********************************************/

void YourHighPriorityISRCode(void);
void YourLowPriorityISRCode(void);

/** VECTOR REMAPPING ***********************************************/

#define REMAPPED_RESET_VECTOR_ADDRESS    0x800
#define REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS  0x808
#define REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS  0x818

//These are your actual interrupt handling routines.
#pragma interrupt YourHighPriorityISRCode
void YourHighPriorityISRCode()
{
       #if defined(USB_INTERRUPT)
        USBDeviceTasks();
       #endif
}  //This return will be a "retfie fast", since this is in a #pragma interrupt section

#pragma code

void main(void)
  {
  USBDeviceInit();  //usb_device.c.  Initializes USB module SFRs and firmware

  #if defined(USB_INTERRUPT)  // defined in usb_config.h
  USBDeviceAttach();
  #endif

  TRISAbits.TRISA0=1;
  TRISB = 0x1F;

  PORTBbits.RB7 = 0;
  PORTBbits.RB6 = 0;
  PORTBbits.RB5 = 0;

  CAM_Status = 100;

  while(1)
    {

    PORTBbits.RB5 = 1;

    if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) continue;

    if(!USBHandleBusy(USB_Control_Out_Handle))  // Check if the endpoint has received any data from the host.
      {
           
      if((!USBHandleBusy(USB_Control_In_Handle)) && (CAM_Status == 100))    
      {
      CAM_Status = 0; // Initiere das Senden von SYNC ()
           
        PORTBbits.RB6 = 1;

                      IN_Control[0] = 70;
                      IN_Control[1] = 70;
                      IN_Control[2] = 70;
                      IN_Control[3] = 70;
                      IN_Control[4] = 70;
                      IN_Control[5] = 70;
                      USB_Control_In_Handle = USBGenWrite(USB_Control_EP_NUM,(BYTE*)&IN_Control[0], 6);
                      }
        USB_Control_Out_Handle = USBGenRead(USB_Control_EP_NUM,(BYTE*)&OUT_Control[0],USB_Control_EP_SIZE);
        }


      
    if((!USBHandleBusy(USB_Control_In_Handle)) && (CAM_Status != 100))    
    {
      PORTBbits.RB7 = 1;
    IN_Control[0] = 70;
      IN_Control[1] = 70;
      IN_Control[2] = 70;
      USB_Control_In_Handle = USBGenWrite (USB_Control_EP_NUM,(BYTE*)&IN_Control[0], 3);
      }
    } //end while (1)
  } //end main


// ****************************************************************
// ************** USB Callback Functions
// ****************************************************************


void USBCBInitEP(void)
  {
    USBEnableEndpoint(USB_Control_EP_NUM,USB_OUT_ENABLED|USB_IN_ENABLED|USB_HANDSHAKE_ENABLED|USB_DISALLOW_SETUP);
USBEnableEndpoint(USB_Data_EP_NUM,USB_OUT_ENABLED|USB_IN_ENABLED|USB_HANDSHAKE_ENABLED|USB_DISALLOW_SETUP);

  USB_Control_Out_Handle = USBGenRead(USB_Control_EP_NUM,(BYTE*)&OUT_Control[0], USB_Control_EP_SIZE);
  USB_Data_Out_Handle = USBGenRead(USB_Data_EP_NUM,(BYTE*)&OUT_Data[0], USB_Data_EP_SIZE);
}

[Benjamin (Gast)]

Hallo,
dasselbe Problem habe ich vermutlich auch.

Wie hast du dies nun gelöst? Oder weiss jemand anderes eine Lösung?

Viele Grüße