Spi.c

Go to the documentation of this file.

 
 
#include "tutti_gli_header.h"
 
// DOCUMENTAZIONE DOXYGEN
 
/// \file
 
/// \file SPI_LPC17xx.c
 
/*! \page SPI_page The SPI bus
\brief <span style="color:red;"> <b> Spi for relays drivers, ADC and Pga DACS </b> </span>
 
 \b SUMMARY:
*\arg \ref user_use_of_SPI
\arg  \ref a_bit_of_SPI_fw
 
*\section user_use_of_SPI User use of SPI
<hr width="75%" size="10" align="left">
 
\n SPI communication follows the same approach adopted for I2C and CAN bus: exploitation of the CMSIS drivers. To this aim there is available a set of functions:
<span style="color:orange;"> <I>
\code {.c}
ARM_DRIVER_SPI Driver_SPI2 = {
  SPI_GetVersion,
  SPI_GetCapabilities,
  SPI_Initialize,      //Important for setting the calling function
  SPI_Uninitialize,    //Idle the SPI
  SPI_PowerControl,    //Switch on/off the SPI
  SPI_Send,            //sen data
  SPI_Receive,         //receive data
  SPI_Transfer,
  SPI_GetDataCount,
  SPI_Control,
  SPI_GetStatus       //usefull for polling
};
\endcode
</I> </span>
 
\n So that an example of their use is the following:
 
<span style="color:orange;"> <I>
\code {.c}
extern ARM_DRIVER_SPI   Driver_SPI2;                                // Viene inclusa la Periferica SPI2
ARM_DRIVER_SPI *SPIdrv= &Driver_SPI2;                               // Viene creato un puntatore a Driver_SPI2
SPIdrv->Control(SPI_control_for_DAC, SPI_DAC_SPEED); // SPI fits DAC specs at 16 bits and speed
\endcode
</I> </span>
 
\n To use the \b SPI first of all we need to intialize it and this is done by SPI_Inizialize() that collects a few functions between those listed above. 
SPI is used by the relay drivers, the ADC and the DAC of the PGA. It is therefore 
set according to them. As an instance, the relay drivers communicate with 8 bits, while the DAC with 16 bits. The core of SPI_Inizialize() 
is the setting of some bits and the clock by calling \b SPIdrv->Control(). The setting bits for \b SPIdrv->Control() are defined at #SPI_control_for_relay_driver 
(the meaning of the bits can be verified at <a href="https://www.keil.com/pack/doc/CMSIS/Driver/html/group__spi__interface__gr.html#gad18d229992598d6677bec250015e5d1a"  target=_blank><b>Bits meaning for SPI settings</b></a>)
with the speed #spi_clock_for_relais, this is the defaul setting. 
\n Every time we manage the realis or the DAC we need to set the SPI accordingly to the parallelism and the speed. For their setting 2 macros are defined:
#SPI_control_for_DAC with #SPI_DAC_SPEED for the DAC and #SPI_control_for_relay_driver with #spi_clock_for_relais for the relais. An example for their setting is here:
 
<span style="color:orange;"> <I>
\code {.c}
SPIdrv->Control(SPI_control_for_DAC, SPI_DAC_SPEED); // SPI fits DAC specs at 16 bits and speed
SPIdrv->Control(SPI_control_for_relay_driver, spi_clock_for_relais); // SPI fits Relay driver specs at 8 bits and speed
\endcode
</I> </span>
 
Where #SPI_control_for_relay_driver is:
\snippet Spi.h ref_SPI_control_for_relay_driver
 
while #spi_clock_for_relais is:
\snippet Detector_Relays_managing.h ref_spi_clock_for_relais
 
\note Pay attention: the SPI clock speed cannot be smaller than 1/255 times the core clock. As an instance, at 100 MHz core clock the 
smaller speed cannot be lower than 400 KHz.
 
\n Transmission and reception is done with \b SPIdrv->Send() and \b SPIdrv->Receive(), and the polling at \b SPIdrv->GetStatus().busy.
\b SPIdrv->GetStatus() ia a structue:
 
\n 
<center>
\anchor Table_status_fields  \b Table \b GetStatus: Fields of the \b SPIdrv->GetStatus().
<span style="color:red;"> The row highlighted in red is the field we test during communication. </span>
| Data Fields  |           |                                                                                                 |
|--------------| :-------: | :-----------------------------------------------------------------------------------------------|
| uint32_t |    <span style="color:red;"> busy: 1   </span> | <span style="color:red;"> Transmitter/Receiver busy flag. </span>  |
| uint32_t |    data_lost: 1 |  Data lost: Receive overflow / Transmit underflow (cleared on start of transfer operation)      |
| uint32_t |    mode_fault: 1   | Mode fault detected; optional (cleared on start of transfer operation)                         |
| uint32_t |    reserved: 29    |                                                                                                |
</center>
 
\n We explooit the field busy, that remains "1" till the SPI operation has concluded.
\n The SPI_callback() is called after SPI operation has concluded, as a result of the interrupt. If  necessary there is available the global
#evento_SPI which can be alternatively checked in polling, or to verify if a problem has occurred. #evento_SPI
can take the following values:
\n 
<center>
\anchor Table_event  \b Table \b Interrupt \b Event: Values that the global #evento_SPI can take.
<span style="color:red;"> The row highlighted in red is the field we test during communication. </span>
Parameter event                 |   Bit       |Description  supported when ARM_SPI_CAPABILITIES
|:------------------------------| :-------: | :-----------------------------------------------------------------------------------------------|
<span style="color:red;"> ARM_SPI_EVENT_TRANSFER_COMPLETE </span> | <span style="color:red;"> 1 << 0 </span>      | <span style="color:red;"> Occurs after call to ARM_SPI_Send, ARM_SPI_Receive, or ARM_SPI_Transfer <br /> to indicate that all the data has been transferred. The driver is ready for the next transfer operation. </span>
ARM_SPI_EVENT_DATA_LOST         | 1 << 1    |   Occurs in slave mode when data is requested/sent by master but send/receive/transfer <br /> operation has not been started and indicates that data is lost. <br /> Occurs also in master mode when driver cannot transfer data fast enough. 
ARM_SPI_EVENT_MODE_FAULT          | 1 << 2    | Occurs in master mode when Slave Select is deactivated and indicates Master Mode Fault. <br /> The driver is ready for the next transfer operation.
</center>
 
Here an example of use of the polled transmission with DAC:
<span style="color:orange;"> <I>
\code {.c}
DAC_transmission(){
SPIdrv->Control(SPI_control_for_DAC, SPI_DAC_SPEED);  //Set the SPI with 16 bits
 
//prepare data to send
uint16_t data_to_send= ...
SPIdrv->Send ( &data_to_send ,1); //send 1 item at 16 bits
while( SPIdrv->GetStatus().busy ){} //wait end of transmission
 
//Function end
}
\endcode
</I> </span>
 
*\section a_bit_of_SPI_fw A bit more about the fw used for SPI
<hr width="75%" size="10" align="left">
 
\n The functions invoked within the fw are the following:
- SPI_Inizialize() is called at startup to set the SPI;
- SPI
 
\n First and only function to be used is the SPI_Inizialize():
\snippet{lineno} SPI.c fun_SPI_Inizialize
 
\n
\n
 
\sa That shown above is an extraction of the documentation from CMSIS drivers. 
For a complete reference to the SPI driver from CMSIS see the webs at Keil or ARM (in case of failure of either): 
- <a href="https://arm-software.github.io/CMSIS_5/Driver/html/group__spi__interface__gr.html"  target=_blank><b>CMSIS doc for SPI from ARM</b></a>, 
- <a href="https://www.keil.com/pack/doc/CMSIS/Driver/html/group__spi__interface__gr.html"  target=_blank><b>CMSIS doc for SPI from KEIL</b></a>
 
\n The codes for SPI is at: 
- \ref Spi.c
- \ref Spi.h
 
*/
/*!
 
*/
extern ARM_DRIVER_SPI   Driver_SPI0;                    // Viene inclusa la Periferica SPI0
ARM_DRIVER_SPI *SPIdrv= &Driver_SPI0;                   // Viene creato un puntatore a Driver_SPI0          
//extern ARM_DRIVER_SPI     Driver_SPI2;                                // Viene inclusa la Periferica SPI2
//ARM_DRIVER_SPI *SPIdrv= &Driver_SPI2;                             // Viene creato un puntatore a Driver_SPI2
uint32_t  evento_SPI; ///< This is the variable which resembles the flags from the communication
uint32_t SPI_speed = SPI_DAC_SPEED; //!< The speed to be set to SPI. It could varies from chip to chip
 
// Viene inizializzato un parametro
//int32_t                                                   status;                         
 
/******************************************************************************
  Callback della Periferica SPI
 ******************************************************************************/
 
//Inizio CROSS
 /*! \brief After that the SPI ends its operations and the interrupt is generated this signal function is called which marks errors, if any
 and flags of operation done.
    
*\param[in]  event  
*\return No parameters
 \showrefby
\showrefs
 
*\snippet{lineno} SPI.c fun_SPI_callback
 */
//! <!-- [fun_SPI_callback] -->
void SPI_callback(uint32_t event)
{
        evento_SPI =event;  //We make the event global
    switch (event)
    {
            case ARM_SPI_EVENT_TRANSFER_COMPLETE:
            {
                    Error_bad_operation = 0;
                    break;      
            }
            case ARM_SPI_EVENT_DATA_LOST:
            {
                    Error_bad_operation = 1;
                    break;      
            }
            case ARM_SPI_EVENT_MODE_FAULT:
            {
                    Error_bad_operation = 2;
                    break;      
            }
    }
}
//! <!-- [fun_SPI_callback] -->
 
/*! \brief SPI is initialized here. Its ise t at 8 bits and 100 KHz, as default
        
*\return No parameters
\showrefby
\showrefs
*\snippet{lineno} SPI.c fun_SPI_Inizialize
 */
//! <!-- [fun_SPI_Inizialize] -->
void SPI_Inizialize(void){
//  int32_t status;
        SPIdrv->PowerControl (ARM_POWER_OFF);     // Terminate any pending transfers, reset IRQ/DMA, power off peripheral
        SPIdrv->Uninitialize ();    
    status = SPIdrv->Initialize (SPI_callback);     // Viene inizializzata la Periferica SPI
    status = SPIdrv->PowerControl(ARM_POWER_FULL);  // Viene accesa la Periferica SPI
 
      status = SPIdrv->Control(SPI_control_for_relay_driver,spi_clock_for_relais); //SPI initialization to relay driver by default
//      status = SPIdrv->Control            (ARM_SPI_SET_BUS_SPEED, spi_clock_for_relais);  //spi_clock_for_relais is our setting
    // Viene configurata la linea SS: INACTIVE = HIGH
    SPIdrv->Control         (ARM_SPI_CONTROL_SS, ARM_SPI_SS_INACTIVE);
}
//! <!-- [fun_SPI_Inizialize] -->
 
//Fine CROSS
 
/*****************************************************************************
    Inizializzazione della Periferica SPI
******************************************************************************/
 
 
/*****************************************************************************
    Inizializzazione della Periferica SPI per il DAC
******************************************************************************/
 /*! \brief SPI is initialized here for DAC. Remember to set the variable SPI_speed before the call. This function is becoming obsolote.
        
*\return No parameters
 \showrefby
\showrefs
*\snippet{lineno} SPI.c fun_SPI_Inizialize_per_il_DAC
 */
//! <!-- [fun_SPI_Inizialize_per_il_DAC] -->
void SPI_Inizialize_per_il_DAC(void)
{
    
        SPIdrv->PowerControl (ARM_POWER_OFF);     // Terminate any pending transfers, reset IRQ/DMA, power off peripheral
        SPIdrv->Uninitialize ();    
// Al DAC servono data bit di 16 bit
    SPIdrv->Initialize  (SPI_callback);                                                             // Viene inizializzata la Periferica SPI
    SPIdrv->PowerControl(ARM_POWER_FULL);                                                               // Viene accesa la Periferica SPI
 
    // Viene configurato SPI: Master, modalit\'a 16 bit, 10000 Kbit/sec
    SPIdrv->Control         (SPI_control_for_DAC , SPI_speed);                          // Viene impostata la modalit\'a a 16 bit
    // Viene configurata la linea SS: INACTIVE = HIGH
    SPIdrv->Control         (ARM_SPI_CONTROL_SS, ARM_SPI_SS_INACTIVE);
}
//! <!-- [fun_SPI_Inizialize_per_il_DAC] -->
 
 
/*****************************************************************************
  SPItx_16_per_il_DAC
******************************************************************************/
void SPItx_16_per_il_DAC(uint16_t dato)
{
// Trasmissione di 2 byte via SPI
    LPC_SPI->SPDR=dato;                                                 // Viene trasmesso il dato
    while (!((LPC_SPI->SPSR & 0x80) == 0x80)){} // Si attende che il flag SPIF si alzi
    dato=LPC_SPI->SPSR;                                                 // Dummy op per azzerare lo status reg
    dato=LPC_SPI->SPDR;                                                 // Dummy op necessaria
}
 
 
/*****************************************************************************
    SPIrx
******************************************************************************/
unsigned char SPIrx(void)
{
// Ricezione di 1 byte via SPI
    unsigned char dato;
    LPC_SPI->SPDR=0x00;                                                 // Viene trasmesso zero
    while (!((LPC_SPI->SPSR&0x80) == 0x80)){}       // Si attende che il flag SPIF si alzi
    dato=LPC_SPI->SPSR;                                                 // Dummy op per azzerare lo status reg
    dato=LPC_SPI->SPDR;                                                 // Viene letto il dato
    return dato;
}
 
 
/*****************************************************************************
    SPIrx24
******************************************************************************/
unsigned long int SPIrx24(void)
{
// Ricezione di 24 bit via SPI (msb first)
    unsigned long int dato;
    dato=SPIrx()<<16;                                                   // Vengono letti i primi 8 bit
    dato=dato+(SPIrx()<<8);                                         // Vengono letti i secondi 8 bit
    dato=dato+SPIrx();                                                  // Vengono letti gli ultimi 8 bit
    return dato;
}