Eval AD7760/62EDZ an FX2

[Patrick V. (Firma: home) (ich27)]

Hallo zusammen...

mein erster Beitrag und dann gleich so eine Frage:

also ich habe hier 2 Eval-Boards:
ein Cypress FX2 Development Board CY3681 PDC-9018 REV C 
(http://www.cypress.com/?rID=14319)
und ein Analog Devices EVAL-AD7760/62EDZ 
(http://www.analog.com/en/analog-to-digital-converters/ad-converters/ad7760/products/product.html)

Ich habe mir das FX2 GPIF Tool Utility-Beispiel von Cypress genommen (zu 
finden in: C:\Cypress\USB\Application Reference Materials\Support 
Information\High Speed Devices\CY7C68013 FX2\Examples) und es ein wenig 
abgewandelt:

in gfpitool.c

void TD_Init( void )
{ // Called once at startup
...
  // 16-bit bus (WORDWIDE=1)...
  SYNCDELAY;                    // 
  EP2FIFOCFG = 0x01;
  SYNCDELAY;                    // 
  EP6FIFOCFG = 0x05;
...
}

...

void TD_Poll( void )
{ // Called repeatedly while the device is idle
  BYTE dummy = 0;
  
  // Handle OUT data...
  
  // is the host sending data...
  if( !( EP2468STAT & 0x01 ) )
  { 
    // EP2EF=0, when endp buffer "not" empty
    
    // ...at this point the pkt. switched from the usb domain to the cpu domain
    
    // if the host sent a pkt... then a buffer was available
    // AUTOOUT=0, so pass pkt. to peripheral domain - (GPIF)
    SYNCDELAY;          // 
    EP2BCL = 0x00;            // w/skip=0

  }
  else
  { 
    // host is "not" sending data...
  }    
  
  if ( write_mode == TRUE ) 
  {
  // is the peripheral interface idle...
  if( GPIFTRIG & 0x80 )
  { 
    // DONE=1, when GPIF is "idle"
  
    // check if there's a pkt in the peripheral domain...
    if( EP24FIFOFLGS & 0x02 )
    { 
      // ...EF=1 when buffer "empty", no more data to xfr.
    }    
    else
    { 
      // EF=0, when slave fifo is "not empty"
      // ...the cpu passed the pkt. to the peripheral domain
    
      // check if peripheral "not full"...
//      if( GPIFREADYSTAT & 0x02 )
      { 
        // RDY1=1, when peripheral is "not" FULL (tied to peripheral "full" flag)
    
//        xFIFOTC_OUT = ( ( EP2FIFOBCH << 8 ) + EP2FIFOBCL );

        // setup GPIF transaction count
        SYNCDELAY;            // 
        EP2GPIFTCH = EP2FIFOBCH;
        SYNCDELAY;
        EP2GPIFTCL = EP2FIFOBCL;  

        // trigger FIFO write transaction(s), using SFR
        // R/W=0, EP[1:0]=00 for EP2 write(s)
        SYNCDELAY;
        GPIFTRIG = GPIFTRIGWR | GPIF_EP2;  
      
        // NOTE: 512 bytes transfers in ~75usec on 8-bit async bus 
        // ...once master (GPIF) drains OUT pkt, it (re)arms to usb domain
/*        
        if( xFIFOTC_OUT < enum_pkt_size )
        { 
          // handle short pkt. to peripheral

          // wait for the transaction to terminate naturally...
          while( !( GPIFTRIG & 0x80 ) )
          { 
              // should take <75usec @ 8-bit async.
            ; // poll GPIFTRIG.7, DONE bit...
          }
          
          // signal "shortpkt" to peripheral peripheral here...
        }
        else
        { 
          // was max. pkt. size...
          // ...let transaction terminate naturally...
        }
*/
      }
//      else
      { 
        // RDY1=0, when peripheral is FULL
      }
    }
  }  
  else
  { 
    // DONE=0 when GPIF is "not" IDLE...
  }
  } else {

if ( EP68FIFOFLGS & 0x01 )
{
  dummy = LED2_ON;
} else {
  dummy = LED2_OFF;
}
if (( GPIFREADYSTAT & 0x01 ))
{
  dummy = LED0_ON;
} else {
  dummy = LED0_OFF;
}
if (!( GPIFREADYSTAT & 0x01 ))
{
  if ( !( GPIFTRIG & 0x80 ) )
  {
    dummy = LED1_ON;
  }
} else {
  dummy = LED1_OFF;
}

// Handle IN data...
  
  
  // is the peripheral interface idle...
  if( GPIFTRIG & 0x80 )
  { 
    // check if peripheral "not empty"...
    if ( !( GPIFREADYSTAT & 0x01 ) )
    { 
      // RDY0=1, when peripheral "not" empty...

      if( EP68FIFOFLGS & 0x01 )
      { 
        // EP6FF=1, when fifo "full"
      }
      else
      { 
        // EP6FF=0, when fifo "not full", buffer available...

        // setup GPIF transaction count
        SYNCDELAY;          // 
        EP6GPIFTCH = 0x00;    
        SYNCDELAY;
        EP6GPIFTCL = 0x04;    
          
        // trigger FIFO read transaction(s), using SFR
        // R/W=1, EP[1:0]=FIFO_EpNum for EPx read(s)
        SYNCDELAY;
        GPIFTRIG = GPIFTRIGRD | GPIF_EP6; 
        
        // NOTE: 512 bytes transfers in ~75usec on 8-bit async bus 
        // NOTE: 64 bytes transfers in ~10usec on 8-bit async bus 
        
        // wait for the transaction to terminate naturally...
        SYNCDELAY;                // 
        while( !( GPIFTRIG & 0x80 ) )
        { 
            // should take <75usec @ 8-bit async.
          ; // poll GPIFTRIG.7, DONE bit...
        }

        
       // AUTOIN=0, so 8051 pass pkt. to host...
        SYNCDELAY;              // 
        INPKTEND = 0x06;        // ...commit however many bytes in pkt.
                                // ...NOTE: this also handles "shortpkt"
        
/*    count++;
      XGPIFSGLDATLX = count;
    count++;
    XGPIFSGLDATH = count;
*/
      }
    }
    else
    { 
      // master has all the data the peripheral sent...
    }
  }
  else
  { 
    // peripheral interface busy...
  }
  }

}

dazu noch ein paar Kleinigkeiten mit den LED's zur Kontrolle von einigen 
Sachen.
Außerdem lasse ich den FX2 vom ADC mit 40MHz synchronisieren (das Zeug 
steht ja dann alles in der gpif.c)

Die Pinbelegung:  ADC -> FX2
MCLK_CED   - IFCLK
DATA[15:0] - FD[15:0]
CS         - CTL1
RD/WR      - CTL2
DRDY       - RDY0

soweit so gut.

Nun die Frage: ich habe also die Waveforms mit dem GPIF-Designer 
geändert und bekomme es einfach nicht gebacken die Daten richtig vom ADC 
aus zulesen. Es ist doch so, dass die FIFORd-Waveform so oft aufgerufen 
wird, wie groß der gewählte FIFO-Puffer gewählt ist, also hier:

        // setup GPIF transaction count
        SYNCDELAY;          // 
        EP6GPIFTCH = 0x00;    
        SYNCDELAY;
        EP6GPIFTCL = 0x04;

4 x 2 Byte = 8 Byte (wegen WIDEWORD)?

Ich habe aber nun das Problem, dass ich zwar Daten (etwas davon) 
bekomme, aber eigentlich möchte ich nur 4 Byte (2 WIDEWORD's) auslesen, 
lese aber mittlerweile 8 aus, weil schon die ersten 2 Bytes, die ich 
bekomme immer(!) auf FF stehen (?). Dann bekomme ich irgendein Byte, 
dann wieder FF, wieder ein Byte, dann wieder FF...
Ich habe einfach das Gefühl, dass die zweiten 8 Bit nicht auslesen kann?
Habe mir das TRM und die AD-Unterlagen schon zu Gemüte geführt (würg), 
weiß jetzt aber nicht weiter?!

Jetzt hoffe ich dass man mit dem Ganzen hier ein wenig was anfangen 
kann?

Danke schonmal

mfg

[ohne ahnung (Gast)]

und dazu noch in nem falschen forum. -> bitte verschieben.