STM32 -> SPI -> AD7142

void RCC_Configuration(void)

{

    /* RCC system reset(for debug purpose) */

    RCC_DeInit();

    /* Enable HSE */

    RCC_HSEConfig(RCC_HSE_ON);

    /* Wait till HSE is ready */

    HSEStartUpStatus = RCC_WaitForHSEStartUp();

    if (HSEStartUpStatus == SUCCESS)

    {

        /* HCLK = SYSCLK */

        RCC_HCLKConfig(RCC_SYSCLK_Div1);

        /* PCLK2 = HCLK/2 */

        RCC_PCLK2Config(RCC_HCLK_Div2);

        /* PCLK1 = HCLK/2 */

        RCC_PCLK1Config(RCC_HCLK_Div2);

        /* PLLCLK = 8MHz * 9 = 72 MHz */

        RCC_PLLConfig(0x00010000, RCC_PLLMul_9);

        /* Enable PLL */

        RCC_PLLCmd(ENABLE);

        /* Wait till PLL is ready */

        while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET) {}

        /* Select PLL as system clock source */

        RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

        /* Wait till PLL is used as system clock source */

        while (RCC_GetSYSCLKSource() != 0x08) {}

    }

    /* Enable peripheral clocks ----------------------------------------------*/

    /* GPIOA, GPIOB and SPI1 clock enable */

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC

            | RCC_APB2Periph_SPI1, ENABLE);

    /* SPI2 Peripheral clock enable */

    RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);

}

> GPIOSPI1_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;  // 5 = SPI1_SCK, 6 = SPI1_MISO, 7 = SPI1_MOSI

>   GPIOSPI1_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

>   GPIOSPI1_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

>   GPIO_Init(GPIOA, &GPIOSPI1_InitStructure);

//MISO

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;       

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;              

    GPIO_Init(GPIOA, &GPIO_InitStructure);

#define  CHX   0x90

#define  CHY   0xD0

#define ADS7843_CS_LOW()     GPIO_ResetBits(GPIO_ADS7843_CS_PORT, RCC_ADS7843_CS)

#define ADS7843_CS_HIGH()    GPIO_SetBits(GPIO_ADS7843_CS_PORT, RCC_ADS7843_CS)

#define SPI1_SCK_LOW()       GPIO_ResetBits(SPI1_PORT, SPI1_SCK)

#define SPI1_SCK_HIGH()      GPIO_SetBits(SPI1_PORT, SPI1_SCK)

#define SPI1_MISO_READ()     GPIO_ReadInputDataBit(SPI1_PORT, SPI1_MISO)

#define SPI1_MOSI_LOW()      GPIO_ResetBits(SPI1_PORT, SPI1_MOSI)

#define SPI1_MOSI_HIGH()     GPIO_SetBits(SPI1_PORT, SPI1_MOSI)

static void ADS7843_SPI_Start( void )

{

    ADS7843_CS_HIGH();

    SPI1_MOSI_HIGH();

    SPI1_SCK_LOW();

    ADS7843_CS_LOW();

}

static void SPI_MOSI(u8 data)

{

    if(data)

        SPI1_MOSI_HIGH();

    else

        SPI1_MOSI_LOW();

}

static void ADS7843_WrCmd(u8 cmd)

{

    u8 buf, i;

    for( i = 0; i < 8; i++ ){

        buf = (cmd >> (7-i)) & 0x1 ;

        SPI_MOSI(buf);

        SPI1_SCK_HIGH();

        SPI1_SCK_LOW();

    }

}

static u16 ADS7843_Read(void)

{

    u16 buf = 0 ;

    u8 i;

    SPI1_SCK_HIGH(); 

    SPI1_SCK_LOW();

    for( i = 0; i < 12; i++ ){

        buf = buf << 1 ;

        SPI1_SCK_HIGH();

        if ( SPI1_MISO_READ() ){

            buf = buf + 1 ;

        }

        SPI1_SCK_LOW();

    }

    for( i = 0; i < 3; i++ ){

        SPI1_SCK_HIGH();

        SPI1_SCK_LOW();

    }

    return( buf ) ;

}

u16 ControlValue;

u16 Register;

u16 testspi = 0xAAAA;

void touchTask(void) 

{

  int i;  

  SPI_InitTypeDef SPI_SPI1_InitStructure;

  GPIO_InitTypeDef GPIOSPI1_InitStructure;

  RCC_Configuration();

  GPIOSPI1_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;  // 5 = SPI1_SCK, 6 = SPI1_MISO, 7 = SPI1_MOSI

  GPIOSPI1_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

  GPIOSPI1_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_Init(GPIOA, &GPIOSPI1_InitStructure);

  GPIOSPI1_InitStructure.GPIO_Pin = GPIO_Pin_4;             // 4 = SPI1_CS

  GPIOSPI1_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

  GPIOSPI1_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_Init(GPIOA, &GPIOSPI1_InitStructure);

  SPI_SPI1_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;

  SPI_SPI1_InitStructure.SPI_Mode = SPI_Mode_Master;

  SPI_SPI1_InitStructure.SPI_DataSize = SPI_DataSize_16b;

  SPI_SPI1_InitStructure.SPI_CPOL = SPI_CPOL_High;

  SPI_SPI1_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;

  SPI_SPI1_InitStructure.SPI_NSS = SPI_NSS_Soft;

  SPI_SPI1_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;

  SPI_SPI1_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;

  SPI_Init(SPI1, &SPI_SPI1_InitStructure);

  SPI_Cmd(SPI1, ENABLE);

  //Read Silicon versions to check communication, It should read 0xE622

  //Create the 16-bit header   

  Register = 0x17;                    // I.D. Register  

  ControlValue   = 0xE400 | (Register & 0x03FF);      

        //   = 0xE417   =   1110 0100 0001 0111

        // [15:11] = 11100  -> enable word

        // [10] = 0  -> R/W

        // [9:0] = [AD9, AD8, AD7, AD6, AD5, AD4, AD3, AD2, AD1, AD0] (STARTING MSB JUSTIFIED REGISTER ADDRESS)        

  for (i=0;i<4000;i++);    // delay

  for(;;) 

  {

    GPIO_ResetBits(GPIOA, GPIO_Pin_4);

    SPI_I2S_SendData(SPI1, ControlValue);  

    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);  

    testspi = SPI_I2S_ReceiveData(SPI1);      // should read 0xE622 

    GPIO_SetBits(GPIOA, GPIO_Pin_4);

    }

}

uint16_t SPI_I2S_ReceiveData(SPI_TypeDef* SPIx)

{

  /* Check the parameters */

  assert_param(IS_SPI_ALL_PERIPH(SPIx));

  /* Return the data in the DR register */

  return SPIx->DR;

}

  for(;;) 

  {

    GPIO_ResetBits(GPIOA, GPIO_Pin_4);

    SPI_I2S_SendData(SPI1, ControlValue);

    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) != RESET){}  

    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);

    testspi = SPI_I2S_ReceiveData(SPI1);      // should read 0xE622 

    GPIO_SetBits(GPIOA, GPIO_Pin_4);

    }

  for(;;) 

  {

    GPIO_ResetBits(GPIOA, GPIO_Pin_4);

    SPI_I2S_SendData(SPI1, ControlValue);

    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) != RESET){}  

    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);

    testspi = SPI_I2S_ReceiveData(SPI1); // read trash.....

    WarteBisDerChipDieAntwortHat_fallsNoetig();

    SPI_I2S_SendData(SPI1, 0xFFFF);

    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) != RESET){}  

    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);

    testspi = SPI_I2S_ReceiveData(SPI1); // read expected data.....

    GPIO_SetBits(GPIOA, GPIO_Pin_4);

    WarteEinBischenHier(); // CS mal auf High gehen lassen....

  }

void spi1init(void) 

{  

  SPI_InitTypeDef SPI_SPI1_InitStructure;

  GPIO_InitTypeDef GPIOSPI1_InitStructure;

  RCC_Configuration();

  GPIOSPI1_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;  // 5 = SPI1_SCK, 6 = SPI1_MISO, 7 = SPI1_MOSI

  GPIOSPI1_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

  GPIOSPI1_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_Init(GPIOA, &GPIOSPI1_InitStructure);

  GPIOSPI1_InitStructure.GPIO_Pin = GPIO_Pin_4;      // 4 = SPI1_CS

  GPIOSPI1_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

  GPIOSPI1_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_Init(GPIOA, &GPIOSPI1_InitStructure);

  SPI_I2S_DeInit(SPI1);

  SPI_SPI1_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;

  SPI_SPI1_InitStructure.SPI_Mode = SPI_Mode_Master;

  SPI_SPI1_InitStructure.SPI_DataSize = SPI_DataSize_16b;

  SPI_SPI1_InitStructure.SPI_CPOL = SPI_CPOL_High;

  SPI_SPI1_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;

  SPI_SPI1_InitStructure.SPI_NSS = SPI_NSS_Soft;

  SPI_SPI1_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;

  SPI_SPI1_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;

    SPI_SPI1_InitStructure.SPI_CRCPolynomial = 7;  

  SPI_Init(SPI1, &SPI_SPI1_InitStructure);  

  SPI_Cmd(SPI1, ENABLE);

}

void RCC_Configuration(void)

{

    /* RCC system reset(for debug purpose) */

    RCC_DeInit();

    /* Enable HSE */

    RCC_HSEConfig(RCC_HSE_ON);

    /* Wait till HSE is ready */

    HSEStartUpStatus = RCC_WaitForHSEStartUp();

    if (HSEStartUpStatus == SUCCESS)

    {

        /* HCLK = SYSCLK */

        RCC_HCLKConfig(RCC_SYSCLK_Div1);

        /* PCLK2 = HCLK/2 */

        RCC_PCLK2Config(RCC_HCLK_Div2);

        /* PCLK1 = HCLK/2 */

        RCC_PCLK1Config(RCC_HCLK_Div2);

        /* PLLCLK = 8MHz * 9 = 72 MHz */

        RCC_PLLConfig(0x00010000, RCC_PLLMul_9);

        /* Enable PLL */

        RCC_PLLCmd(ENABLE);

        /* Wait till PLL is ready */

        while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET) {}

        /* Select PLL as system clock source */

        RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

        /* Wait till PLL is used as system clock source */

        while (RCC_GetSYSCLKSource() != 0x08) {}

    }

    /* Enable peripheral clocks ----------------------------------------------*/

    /* GPIOA enable */

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    /* SPI1 enable */

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);

}

void ReadFromAD7142ViaSpi(const u16 RegisterStartAddress, const u8 NumberOfRegisters, u16 *DataBuffer, const u16 OffsetInBuffer)

{

  u16 ControlValue;

  u8 i,j, RegisterIndex;

  u16 InputValue;

  ControlValue = 0xE400 | (RegisterStartAddress & 0x03FF);    //Create the 16-bit header

  for (i=0;i<100;i++);    // delay

  //Write out the control word

  GPIO_ResetBits(GPIOA, GPIO_Pin_4);    // CS low

  SPI_I2S_SendData(SPI1, ControlValue);

  while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) != RESET);  

  while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);

  InputValue = SPI_I2S_ReceiveData(SPI1);   // Read dummy

  //Copy each register in the buffer contiguously.

  //Read data in.

  for (RegisterIndex=0; RegisterIndex<NumberOfRegisters; RegisterIndex++)

  {

    SPI_I2S_SendData(SPI1, 0xFFFF);

    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) != RESET); 

    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);

    InputValue = SPI_I2S_ReceiveData(SPI1);   // read data

    *(DataBuffer+OffsetInBuffer+RegisterIndex)=(u16)InputValue;

  }

  GPIO_SetBits(GPIOA, GPIO_Pin_4);    // CS high

  for (j=0;j<5;j++);      // delay

}

void WriteToAD7142ViaSpi(const u16 RegisterAddress, const u8 NumberOfRegisters, u16 *DataBuffer, const u8 OffsetInBuffer)

{

  u16 ControlValue;

  u16 ValueToWrite;

  u16 RegisterIndex;

  u8 j;

  ControlValue = 0xE000 | (RegisterAddress & 0x03FF);    //Create the 16-bit header

  //Write out the control word

  GPIO_ResetBits(GPIOA, GPIO_Pin_4);    // CS low

  SPI_I2S_SendData(SPI1, ControlValue);

  while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) != RESET);  

  while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);

  //And then the data

  for (RegisterIndex=0; RegisterIndex<NumberOfRegisters; RegisterIndex++)

  {

    ValueToWrite= *(DataBuffer+RegisterIndex+OffsetInBuffer);

    SPI_I2S_SendData(SPI1, ValueToWrite);

    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) != RESET); 

    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);

  }

  GPIO_SetBits(GPIOA, GPIO_Pin_4);    // CS high

  for (j=0;j<5;j++);            // delay

}