SSP mit Interrupts LPC2148

[mgiaco (Gast)]

Hallo,

Hat jemand für mich vielleicht einen Code für das SSP Modul mit 
Interrupts.

Das Beispiel von NXP funktioniert nicht bei mir zudem finde ich es auch 
etwas kommisch.

Warum: Das ist ein Teil vom ISR Handler RX IRQ.

 /* please be aware that, in main and ISR, CurrentRxIndex and CurrentTxIndex
    are shared as global variables. It may create some race condition that main
    and ISR manipulate these variables at the same time. SSPSR_BSY checking (polling)
    in both main and ISR could prevent this kind of race condition */
    if ( regValue & SSPMIS_RXMIS )  /* Rx at least half full */
    {
     interruptRxStat++;    /* receive until it's empty */
       
     while ( SSPSR & SSPSR_RNE )  
     {
         SPIRDData[CurrentRxIndex++] = SSPDR;
         /* Wait until the Busy bit is cleared */
         while ( !(SSPSR & SSPSR_BSY) );
     }   /* interrupt will be cleared when */
         /* data register is read or written */  
    }

Wenn man aber ssptest analysiert, findet man folgendes:

   /* No need to consider CurrentTxIndex because it will always transmit 
    as long as CurrentRxIndex is less than BUFSIZE. Once CurrentRxIndex reaches 
    BUFSIZE, it has received the complete block of data, then we bail out on 
    transmit. */
    IOCLR0 = SPI1_SEL;
    while ( CurrentRxIndex <= BUFSIZE )
    {
        /* to check the RXIM and TXIM interrupt, I send a block data at one time 
  based on the FIFOSIZE(8). */
        SPI1Send( (BYTE *)&SPIWRData[CurrentTxIndex], FIFOSIZE );
        SPI1Receive( (BYTE *)&SPIRDData[CurrentRxIndex], FIFOSIZE );
    }
    IOSET0 = SPI1_SEL;

Die Funktion für SPI1Receive sollte doch aus dem Buffer lesen solange 
was vorhanden ist macht Sie aber nicht diese holt es direkt aus dem 
Empfangsregister:

/*****************************************************************************
** Function name:    SPI1Receive
** Descriptions:    the module will receive a block of data from 
**        the SPI1(SSP), the 2nd parameter is the block 
**        length.
** parameters:      buffer pointer, and block length
** Returned value:    None
** 
*****************************************************************************/
void SPI1Receive( uint8_t *buf, uint8_t Length )
{
    uint8_t i;
 
    for ( i = 0; i < Length; i++ )
    {
  /* As long as Receive FIFO is not empty, I can always receive. */
  /* since it's a loopback test, clock is shared for both TX and RX,
  no need to write dummy uint8_t to get clock to get the data */
  /* if it's a peer-to-peer communication, SSPDR needs to be written
  before a read can take place. */
  SSPDR = 0xFF;
  while ( !(SSPSR & SSPSR_RNE) );
  *buf = SSPDR;  // <<-- ????
  buf++;
  CurrentRxIndex++;
    }
    return; 
}

Also kann mir vielleicht mal jemand das Beispiel erkären? Das ist doch 
nicht korrekt. Der Interrupt kann doch nie zustande kommen wenn die 
Recieve Routine das Register immer gleich aussliest, und diese sollte 
doch nicht aus dem Register sonder aus dem Buffer lesen oder nicht?

Besten Dank schon mal

[mgiaco (Gast)]

Hat niemand ein Beispiel was er weiter gibt?