Exemplo n.º 1
0
// SPI basic Read/Write function
u8 SPI_RW_Byte(SPI_TypeDef* SPIx,unsigned char Byte)
{
		while( SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET)   	  __nop();
		SPI_I2S_SendData(SPIx, Byte);
		while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_RXNE) == RESET)  	  __nop();
		return SPI_I2S_ReceiveData(SPIx);
}
Exemplo n.º 2
0
void SPI2_EventHandler(void)
{	

	SPI2_TimeOut=0;
	SPI2_Status =0;
	//Ricevo il dato dal MOSI 
	RCHK	+= (SPI2_Buffer_Rx[RxIdx] = SPI_I2S_ReceiveData(SPI2));
  
	if (RxIdx++==_psize){
		if(RCHK==0)
		{ //Nuovo Messaggio ricevuto			
			if( _SPI2_RX_Event)	_SPI2_RX_Event();			
		}
		else
		{
			SPI2_Status =0x80;		
		}
		//	*p= (~CHK)+1;
		TCHK=RCHK=RxIdx=0;	
		
	}
	//Preparo il dato sul MISO
	TCHK +=  SPI2_Buffer_Tx[RxIdx];
	if (RxIdx==_psize)
	{
		SPI_I2S_SendData(SPI2, (~TCHK)+1);	
	}
	else
	{
			SPI_I2S_SendData(SPI2, SPI2_Buffer_Tx[RxIdx]);
	}
}
Exemplo n.º 3
0
void caribou_spi_select(caribou_spi_t* spi)
{
	GPIO_ClearBits(spi->select_port,1<<spi->select_pin);
	/* clear the receiver */
	while ( SPI_I2S_GetFlagStatus(spi->select_port, SPI_I2S_FLAG_RXNE) == SET )
		SPI_I2S_ReceiveData(spi->select_port);
}
Exemplo n.º 4
0
u8 SPI_RW(u8 dat) 
{ 
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET); 
    SPI_I2S_SendData(SPI1, dat); 
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);  
    return SPI_I2S_ReceiveData(SPI1); 
}
Exemplo n.º 5
0
/**
 * Send/Receive 1 Byte through SPI
 * @param spi SPI index number (@ref wizpf_spi)
 * @param byte 1 Byte to send
 * @return Received 1 Byte
 */
uint8 wizpf_spi_byte(wizpf_spi spi, uint8 byte)
{
	SPI_TypeDef *SPIx;

	switch(spi) {
	case WIZ_SPI1:
#if defined(SPI1_SCS_PIN) && defined(SPI1_SCLK_PIN) && defined(SPI1_MISO_PIN) && defined(SPI1_MOSI_PIN)
		SPIx = SPI1;
		break;
#else
		LOG("Not implemented");
		return 0; 
#endif
	case WIZ_SPI2:
#if defined(SPI2_SCS_PIN) && defined(SPI2_SCLK_PIN) && defined(SPI2_MISO_PIN) && defined(SPI2_MOSI_PIN)
		SPIx = SPI2;
		break;
#else
		LOG("Not implemented");
		return 0; 
#endif
	//case WIZ_SPI3:
	//	break;
	default:
		ERRA("SPI(%d) is not allowed", spi);
		return 0;
	}

	while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET);         
	SPI_I2S_SendData(SPIx, byte);          
	while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_RXNE) == RESET);          
	return (uint8)SPI_I2S_ReceiveData(SPIx);
}
Exemplo n.º 6
0
/**
  * @brief  This function handles SPI interrupt request.
  * @param  None
  * @retval None
  */
void SPIx_IRQHANDLER(void)
{
#ifdef SPI_SLAVE
  /* SPI in Slave Receiver mode--------------------------------------- */
  if (SPI_I2S_GetITStatus(SPIx, SPI_I2S_IT_RXNE) == SET)
  {
    RxBuffer[Rx_Idx++] = SPI_I2S_ReceiveData(SPIx);
  }
#endif
#ifdef SPI_MASTER
  /* SPI in Master Tramitter mode--------------------------------------- */
  if (SPI_I2S_GetITStatus(SPIx, SPI_I2S_IT_TXE) == SET)
  {
    if (CmdStatus == 0x00)
    {
        /* Send Transaction code */
      SPI_I2S_SendData(SPIx, CmdTransmitted);
      CmdStatus = 0x01;
    }
    else
    {
      if (Tx_Idx < GetVar_NbrOfData())
      {
          /* Send Transaction data */
        SPI_I2S_SendData(SPIx, TxBuffer[Tx_Idx++]);
      }
      else
      {
        /* Disable the Tx buffer empty interrupt */
        SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_TXE, DISABLE);
      }
    }
  }
#endif /* SPI_SLAVE */
}
void W5500WriteByte(unsigned char byte)
{
	while (SPI_I2S_GetFlagStatus(W5500_SPI, SPI_I2S_FLAG_TXE) == RESET);
	SPI_I2S_SendData(W5500_SPI, byte);
	while (SPI_I2S_GetFlagStatus(W5500_SPI, SPI_I2S_FLAG_RXNE) == RESET);
	SPI_I2S_ReceiveData(W5500_SPI);
}
Exemplo n.º 8
0
uint8_t SpiInOut( uint8_t outData )
{
    /* Send SPIy data */
    SPI_I2S_SendData( SPI_INTERFACE, outData );
    while( SPI_I2S_GetFlagStatus( SPI_INTERFACE, SPI_I2S_FLAG_RXNE ) == RESET );
    return SPI_I2S_ReceiveData( SPI_INTERFACE );
}
Exemplo n.º 9
0
/*************************************************
  Function:		hw_spi2_writereg
  Description:  
  Input:		
  Output:		
  Return:		
  Others:
*************************************************/
uint16_t hw_spi2_writereg(uint16_t data)
{
	while (SPI_I2S_GetFlagStatus(SPI2_SPI, SPI_I2S_FLAG_TXE) == RESET);
	SPI_I2S_SendData(SPI2_SPI, data);
	while (SPI_I2S_GetFlagStatus(SPI2_SPI, SPI_I2S_FLAG_RXNE) == RESET);
    return  SPI_I2S_ReceiveData(SPI2_SPI);
}
Exemplo n.º 10
0
void SPI1_Set(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, uint8_t adress, uint8_t data){

	GPIO_ResetBits(GPIOx, GPIO_Pin); //CS->0

	while(!SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE));  //transmit buffer empty?
	SPI_I2S_SendData(SPI1, adress);
	while(!SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE)); //data received?
	SPI_I2S_ReceiveData(SPI1);

	while(!SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE));  //transmit buffer empty?
	SPI_I2S_SendData(SPI1, data);
	while(!SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE)); //data received?
	SPI_I2S_ReceiveData(SPI1);

	GPIO_SetBits(GPIOx, GPIO_Pin); //CS->1
}
Exemplo n.º 11
0
static uint8_t spiWriteRead(uint8_t data)
{
  SPI_I2S_SendData(SPI1, data);
  while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET) {}
  data = (uint8_t)SPI_I2S_ReceiveData(SPI1);
  return data;
}
Exemplo n.º 12
0
/**
  * @brief  Sends a Byte through the SPI interface and return the Byte received
  *         from the SPI bus.
  * @param  Byte : Byte send.
  * @retval The received byte value
  */
static uint8_t BMA250E_SendByte(uint8_t byte)
{

   
  /* Loop while DR register in not empty */
  BMA250ETimeout = BMA250E_FLAG_TIMEOUT;
  while (SPI_I2S_GetFlagStatus(BMA250E_SPI, SPI_I2S_FLAG_TXE) == RESET)
  {
#ifdef USE_DEFAULT_TIMEOUT_CALLBACK
    if((BMA250ETimeout--) == 0) return BMA250E_TIMEOUT_UserCallback();
#endif
  }

  /* Send a Byte through the SPI peripheral */
  SPI_I2S_SendData(BMA250E_SPI, (uint16_t)byte);

  /* Wait to receive a Byte */
  BMA250ETimeout = BMA250E_FLAG_TIMEOUT;
  while (SPI_I2S_GetFlagStatus(BMA250E_SPI, SPI_I2S_FLAG_RXNE) == RESET)
  {
#ifdef USE_DEFAULT_TIMEOUT_CALLBACK
    if((BMA250ETimeout--) == 0) return BMA250E_TIMEOUT_UserCallback();
#endif
  }

  /* Return the Byte read from the SPI bus */
  return (uint8_t)SPI_I2S_ReceiveData(BMA250E_SPI);

}
Exemplo n.º 13
0
char jbSPIReceive(SPI_TypeDef* SPIx)
{
    while(!SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE));  // Wait until it resets itself
    SPI_I2S_SendData(SPIx, 0x00);
    while(!SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_RXNE));
    return (char)SPI_I2S_ReceiveData(SPIx);
}
Exemplo n.º 14
0
uint8_t SPI_Read_One_Byte(SPI_TypeDef *SPIx)
{
    /* wait untill Receive one byte */
    while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_RXNE) == RESET);
    /* Receive a Byte through the SPI peripheral */
    return SPI_I2S_ReceiveData(SPIx);
}
unsigned char W5500ReadByte(void)
{
	while (SPI_I2S_GetFlagStatus(W5500_SPI, SPI_I2S_FLAG_TXE) == RESET);
	SPI_I2S_SendData(W5500_SPI, 0xff);
	while (SPI_I2S_GetFlagStatus(W5500_SPI, SPI_I2S_FLAG_RXNE) == RESET);
	return SPI_I2S_ReceiveData(W5500_SPI);
}
Exemplo n.º 16
0
/**
 * @brief  Send one Byte through the SPI interface and return the received Byte
 * @param  uint8_t byte  The byte to send
 * @retval uint8_t The received byte value
 */
static uint8_t _LIS302DL_SendByte(SPI_TypeDef* spi, uint8_t byte) {
	volatile uint32_t _LIS302DL_Timeout = LIS302DL_MAX_TIMEOUT;
	
	// Loop while DR register in not empty; or we ran into a timeout
	_LIS302DL_Timeout = LIS302DL_MAX_TIMEOUT;
	while (SPI_I2S_GetFlagStatus(spi, SPI_I2S_FLAG_TXE) == RESET) {
		if ((_LIS302DL_Timeout--) == 0) {
			return LIS302DL_TIMEOUT_UserCallback();
		}
	}
	
	// Send a Byte through the SPI peripheral
	SPI_I2S_SendData(spi, byte);
	
	// Wait to receive a Byte; or we ran into a timeout
	_LIS302DL_Timeout = LIS302DL_MAX_TIMEOUT;
	while (SPI_I2S_GetFlagStatus(spi, SPI_I2S_FLAG_RXNE) == RESET) {
		if ((_LIS302DL_Timeout--) == 0) {
			return LIS302DL_TIMEOUT_UserCallback();
		}
	}
	
	/* Return the Byte read from the SPI bus */
	return (uint8_t)SPI_I2S_ReceiveData(spi);
}
Exemplo n.º 17
0
uint8 wizspi_byte(uint8 byte)
{
	while (SPI_I2S_GetFlagStatus(wizspix, SPI_I2S_FLAG_TXE) == RESET);         
	SPI_I2S_SendData(wizspix, byte);          
	while (SPI_I2S_GetFlagStatus(wizspix, SPI_I2S_FLAG_RXNE) == RESET);          
	return SPI_I2S_ReceiveData(wizspix);
}
/**
  * @brief  This function handles SPI interrupt request.
  * @param  None
  * @retval None
  */
void SPIx_IRQHANDLER(void)
{
  /* SPI in Receiver mode */
  if (SPI_I2S_GetITStatus(SPIx, SPI_I2S_IT_RXNE) == SET)
  {
    if (ubRxIndex < BUFFERSIZE)
    {
      /* Receive Transaction data */
      aRxBuffer[ubRxIndex++] = SPI_I2S_ReceiveData(SPIx);
    }
    else
    {
      /* Disable the Rx buffer not empty interrupt */
      SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_RXNE, DISABLE);
    }
  }
  /* SPI in Transmitter mode */
  if (SPI_I2S_GetITStatus(SPIx, SPI_I2S_IT_TXE) == SET)
  {
    if (ubTxIndex < BUFFERSIZE)
    {
      /* Send Transaction data */
      SPI_I2S_SendData(SPIx, aTxBuffer[ubTxIndex++]);
    }
    else
    {
      /* Disable the Tx buffer empty interrupt */
      SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_TXE, DISABLE);
    }
  }
}
Exemplo n.º 19
0
static uint8_t sendByte(uint8_t byte) {

  while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET){};
  SPI_I2S_SendData(SPI2,byte);
  while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET){};
  return(SPI_I2S_ReceiveData(SPI2));
}
Exemplo n.º 20
0
/**
  * @brief  This function handles SPI interrupt request.
  * @param  None
  * @retval None
  */
void BSP_SPIx_IRQHANDLER(void)
{
	//Debug_ShowRegister( SPI2_BASE, (DebugPeripheralTypedef *)&DeBugSPI );
  /* SPI in Receiver mode */
  if (SPI_I2S_GetITStatus(BSP_SPIx, SPI_I2S_IT_RXNE) == SET)
  {
    if (ubRxIndex < BUFFERSIZE)
    {
      /* Receive Transaction data */
      aRxBuffer[ubRxIndex++] = SPI_I2S_ReceiveData(BSP_SPIx);
    }
    else
    {
      /* Disable the Rx buffer not empty interrupt */
      SPI_I2S_ITConfig(BSP_SPIx, SPI_I2S_IT_RXNE, DISABLE);
    }
  }
  /* SPI in Transmitter mode */
  if (SPI_I2S_GetITStatus(BSP_SPIx, SPI_I2S_IT_TXE) == SET)
  {
    if (ubTxIndex < BUFFERSIZE)
    {
      /* Send Transaction data */
      SPI_I2S_SendData(BSP_SPIx, aTxBuffer[ubTxIndex++]);
    }
    else
    {
      /* Disable the Tx buffer empty interrupt */
      SPI_I2S_ITConfig(BSP_SPIx, SPI_I2S_IT_TXE, DISABLE);
    }
  }
}
Exemplo n.º 21
0
uint8_t spiTransfer(uint8_t *out, uint8_t *in, int len)
{

    uint16_t spiTimeout;
    uint8_t b;

    SPI_BUSE->DR;

    while (len--) {
        b = in ? *(in++) : 0xFF;
        spiTimeout = 1000;
        while (SPI_I2S_GetFlagStatus(SPI_BUSE, SPI_I2S_FLAG_TXE) == RESET) {
            if ((spiTimeout--) == 0)
                return spiTimeoutUserCallback();
        }
        SPI_I2S_SendData(SPI_BUSE, b);
        spiTimeout = 1000;
        while (SPI_I2S_GetFlagStatus(SPI_BUSE, SPI_I2S_FLAG_RXNE) == RESET) {
            if ((spiTimeout--) == 0)
                return spiTimeoutUserCallback();
        }

        b = SPI_I2S_ReceiveData(SPI_BUSE);
        if (out)
            *(out++) = b;
    }

    return true;
}
Exemplo n.º 22
0
bool spiTransfer(SPI_TypeDef *instance, uint8_t *out, const uint8_t *in, int len)
{
    uint16_t spiTimeout = 1000;

    uint8_t b;
    instance->DR;
    while (len--) {
        b = in ? *(in++) : 0xFF;
        while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET) {
            if ((spiTimeout--) == 0)
                return spiTimeoutUserCallback(instance);
        }
#ifdef STM32F303xC
        SPI_SendData8(instance, b);
#else
        SPI_I2S_SendData(instance, b);
#endif
        spiTimeout = 1000;
        while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_RXNE) == RESET) {
            if ((spiTimeout--) == 0)
                return spiTimeoutUserCallback(instance);
        }
#ifdef STM32F303xC
        b = SPI_ReceiveData8(instance);
#else
        b = SPI_I2S_ReceiveData(instance);
#endif
        if (out)
            *(out++) = b;
    }

    return true;
}
Exemplo n.º 23
0
/**
 * @brief	Writes and receives data from the SPI
 * @param	Data: data to be written to the SPI
 * @retval	The received data
 */
uint8_t SPI1_WriteRead(uint8_t Data)
{
#if 0 /* This adds overhead */
	/* Loop while DR register is not empty */
	while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET);

	/* Send byte through the SPIx peripheral */
	SPI_I2S_SendData(SPIx, (uint16_t)Data);

	/* Wait to receive a byte */
	while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_RXNE) == RESET);

	/* Return the byte read from the SPI bus */
	return SPI_I2S_ReceiveData(SPIx);
#endif

#if 1 /* This is faster */
	/* Loop while DR register is not empty */
	while ((SPIx->SR & SPI_I2S_FLAG_TXE) == RESET);
	/* Send byte through the SPIx peripheral */
	SPIx->DR = Data;
	/* Wait to receive a byte */
	while ((SPIx->SR & SPI_I2S_FLAG_RXNE) == RESET);
	return SPIx->DR;
#endif
}
Exemplo n.º 24
0
bool spiTransfer(uint8_t *out, uint8_t *in, int len)
{
    uint8_t b;
    SPI2->DR;
    while (len--) {
        b = in ? *(in++) : 0xFF;
        while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET);
#ifdef STM32F303xC
        SPI_I2S_SendData16(SPI2, b);
#endif
#ifdef STM32F10X_MD
        SPI_I2S_SendData(SPI2, b);
#endif
        while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET);
#ifdef STM32F303xC
        b = SPI_I2S_ReceiveData16(SPI2);
#endif
#ifdef STM32F10X_MD
        b = SPI_I2S_ReceiveData(SPI2);
#endif
        if (out)
            *(out++) = b;
    }

    return true;
}
Exemplo n.º 25
0
uint8_t spi_read_write_byte(uint8_t txData)
{			
	while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
	SPI_I2S_SendData(SPI1, txData); 
	while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
	return SPI_I2S_ReceiveData(SPI1);
}
Exemplo n.º 26
0
void DMA1_Stream4_IRQHandler(void)
{
	u16 i;
	u8 tmp;
	if(DMA_GetITStatus(DMA1_Stream4, DMA_IT_TCIF4) == SET)
	{
		TP3_L;
		DMA_ClearITPendingBit(DMA1_Stream4, DMA_IT_TCIF4);
		for(i=0;i<200;i++)
		{
			__nop();
		}
		DMA_Cmd(DMA1_Stream4,DISABLE);
		SPI_I2S_DMACmd(SPIFLASH_SPI,SPI_I2S_DMAReq_Tx,DISABLE);
		tmp=SPI_I2S_ReceiveData(SPIFLASH_SPI);
		SPIFLASH_CS_H;
		DMA_Tx_Busy = 0;
		TP3_H;
	}
	else if(DMA_GetITStatus(DMA1_Stream4,DMA_IT_TEIF4) == SET)
	{
		__nop();
		DMA_ClearITPendingBit(DMA1_Stream4, DMA_IT_TEIF4);
	}
}
Exemplo n.º 27
0
uint8_t uSpiRead( SPI_TypeDef* SPIx )
{
    /* Wait until transmission complete */
    while( !SPI_I2S_GetFlagStatus( SPIx, SPI_I2S_FLAG_RXNE ) );

    return SPI_I2S_ReceiveData( SPIx );
}
Exemplo n.º 28
0
static void WR_CMD (uint8_t cmd)
{
  while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
  SPI_I2S_SendData(SPI1,cmd);
  while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
  SPI_I2S_ReceiveData(SPI1);
}
Exemplo n.º 29
0
/*! ------------------------------------------------------------------------------------------------------------------
 * Function: writetospi()
 *
 * Low level abstract function to write to the SPI
 * Takes two separate byte buffers for write header and write data
 * returns 0 for success, or -1 for error
 */
int writetospi
(
    uint16       headerLength,
    const uint8 *headerBuffer,
    uint32       bodylength,
    const uint8 *bodyBuffer
)
{

	int i=0;

    decaIrqStatus_t  stat ;

    stat = decamutexon() ;

    /* Wait for SPIx Tx buffer empty */
    //while (port_SPIx_busy_sending());

	dw_set_device_select();		//cs low

    for(i=0; i<headerLength; i++)
    {
			while (SPI_I2S_GetFlagStatus(DW1000_SPI, SPI_I2S_FLAG_TXE) == RESET){}
			SPI_I2S_SendData(DW1000_SPI, headerBuffer[i]);
    	//port_SPIx_send_data(headerBuffer[i]); //send data on the SPI
			while (SPI_I2S_GetFlagStatus(DW1000_SPI, SPI_I2S_FLAG_RXNE) == RESET){}
			SPI_I2S_ReceiveData(DW1000_SPI);
    }

    for(i=0; i<bodylength; i++)
    {
			while (SPI_I2S_GetFlagStatus(DW1000_SPI, SPI_I2S_FLAG_TXE) == RESET){}
			SPI_I2S_SendData(DW1000_SPI, bodyBuffer[i]);
		//port_SPIx_send_data(bodyBuffer[i]); //send data on the SPI
			while (SPI_I2S_GetFlagStatus(DW1000_SPI, SPI_I2S_FLAG_RXNE) == RESET){}
			SPI_I2S_ReceiveData(DW1000_SPI);
		//while (port_SPIx_no_data()); //wait for rx buffer to fill

		//port_SPIx_receive_data(); //this clears RXNE bit
	}

    dw_reset_device_select();  //CS high

    decamutexoff(stat) ;

    return 0;
} // end writetospi()
Exemplo n.º 30
0
kick_scheduler_t spi_isr() {
#ifdef SPI_IN_INTERRUPT_MODE
   // save the byte just received in the RX buffer
   switch (spi_vars.returnType) {
      case SPI_FIRSTBYTE:
         if (spi_vars.numTxedBytes==0) {
            *spi_vars.pNextRxByte = SPI_I2S_ReceiveData(SPI2);
         }
         break;
      case SPI_BUFFER:
         *spi_vars.pNextRxByte    = SPI_I2S_ReceiveData(SPI2);
         spi_vars.pNextRxByte++;
         break;
      case SPI_LASTBYTE:
         *spi_vars.pNextRxByte    = SPI_I2S_ReceiveData(SPI2);
         break;
   }
   
   // one byte less to go
   spi_vars.pNextTxByte++;
   spi_vars.numTxedBytes++;
   spi_vars.txBytesLeft--;
   
   if (spi_vars.txBytesLeft>0) {
      // write next byte to TX buffer
   SPI_SendData(SPI2,*spi_vars.pNextTxByte);
   } else {
      // put CS signal high to signal end of transmission to slave
      if (spi_vars.isLast==SPI_LAST) {
   GPIO_SetBits(GPIOA, GPIO_Pin_4);
      }
      // SPI is not busy anymore
      spi_vars.busy          =  0;
      
      // SPI is done!
      if (spi_vars.callback!=NULL) {
         // call the callback
         spi_vars.callback();
         // kick the OS
         return 1;
      }
   }
#else
   while(1);// this should never happen
#endif
}