Working with STM32 and I2S Part 1 : Introduction

STM32F407xx

#include "stm32f4xx.h"

void SystemInit(void)
{
#define PLL_M      4
#define PLL_N      168
#define PLL_P      2
#define PLL_Q      9

__IO uint32_t StartUpCounter = 0, HSEStatus = 0;


  RCC->CR |= ((uint32_t)RCC_CR_HSEON);


  do
  {
	HSEStatus = RCC->CR & RCC_CR_HSERDY;
	StartUpCounter++;
  } while((HSEStatus == 0) && (StartUpCounter != 3000));

  if ((RCC->CR & RCC_CR_HSERDY) != RESET)
  {
	HSEStatus = (uint32_t)0x01;
  }
  else
  {
	HSEStatus = (uint32_t)0x00;
  }

  if (HSEStatus == (uint32_t)0x01)
  {

	RCC->APB1ENR |= RCC_APB1ENR_PWREN;
	PWR->CR &= (uint32_t)~(PWR_CR_VOS);


	RCC->CFGR |= RCC_CFGR_HPRE_DIV1;


	RCC->CFGR |= RCC_CFGR_PPRE2_DIV1;


	RCC->CFGR |= RCC_CFGR_PPRE1_DIV2;


	RCC->PLLCFGR = PLL_M | (PLL_N << 6) | (((PLL_P >> 1) -1) << 16) |
				   (RCC_PLLCFGR_PLLSRC_HSE) | (PLL_Q << 24);


	RCC->CR |= RCC_CR_PLLON;


	while((RCC->CR & RCC_CR_PLLRDY) == 0)
	{
	}

	/* Configure Flash prefetch, Instruction cache, Data cache and wait state */
	FLASH->ACR = FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;


	/* Select the main PLL as system clock source */
	RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
	RCC->CFGR |= RCC_CFGR_SW_PLL;

	/* Wait till the main PLL is used as system clock source */
	while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL)
	{;}
  }
  else
  { /* If HSE fails to start-up, the application will have wrong clock
		 configuration. User can add here some code to deal with this error */
  }

  /*Enable FPU*/
  SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2));

  /*Enable cell compensation*/
  RCC->APB2ENR|=RCC_APB2ENR_SYSCFGEN ;
  SYSCFG->CMPCR|=(1<<0);
  while(!((SYSCFG->CMPCR)&(1<<8))){;}


}

#ifndef __delay__H__
#define __delay__H__

#include "stdint.h"

/*
 * @brief This function will initialize SysTick
 * to generate 1ms interrupt.
 * @param freq source frequency of SysTick.
 * @return nothing.
 * @see Generic ARM CortexM4 user guide.
 * */

void delay_init(uint32_t freq);

/*
 * @brief This function will return the current millis.
 *
 * @param nothing.
 * @return current millis.
 * */
uint64_t millis();


/*
 * @brief This function will spin lock the CPU to delay for the required
 * amount
 * @param time to be delayed in milliseconds.
 * @return nothing.
 * */
void delay(uint32_t time);


#endif /* DELAY_H_ */

#include <delay.h>
#include "stm32f4xx.h"


#define	CTRL_ENABLE					(1U<<0) /*Enable SysTick Timer*/
#define CTRL_CLKSRC					(1U<<2) /*Clock source selection*/
#define CTRL_COUNTFLAG				(1U<<16) /*Count flag bit*/
#define CTRL_TICKINT				(1U<<1) /*Interrupt enable bit*/


volatile uint64_t mil; /*volatile variable to hold the ms counter*/

void delay_init(uint32_t freq)
{

	/*Set period to be 1ms*/
	SysTick->LOAD  = (freq/1000) - 1;

	/*Clear systick current value register */
	SysTick->VAL = 0;

	/*Enable systick and select internal clk src*/
	SysTick->CTRL = CTRL_ENABLE | CTRL_CLKSRC ;

	/*Enable systick interrupt*/
	SysTick->CTRL  |= CTRL_TICKINT;

}



uint64_t millis()
	{

	__disable_irq(); /*Disable global interrupt*/

	uint64_t ml=mil; /*Get the current millis values and store in ml*/

	__enable_irq(); /*Enable global interrupt*/

	return ml;		/*Return the stored value*/
	}


/*Spin lock the CPU to delay*/
void delay(uint32_t time)
{

	uint64_t start=millis();
	while((millis() - start) < (time+1));
}

/*Interrupt handler of SysTick*/
void SysTick_Handler(void)
{
	/*Increment the counter with every interrupt*/
	mil++;
}

#ifndef I2C_H_
#define I2C_H_


#include "stm32f4xx.h"                  // Device header
#include "delay.h"
#include "stdint.h"



void i2c_init(void);
char i2c_readByte(char saddr,char maddr,char *data);
void i2c_writeByte(char saddr,char maddr,char data);
void i2c_WriteMulti(char saddr,char maddr,char *buffer, uint8_t length);
void i2c_ReadMulti(char saddr,char maddr, int n, char* data);



#endif

#include "i2c.h"

uint8_t inited=0;

void i2c_init(void)
{
	#define I2C1_AF 0x04

	if(inited==0)
	{
		RCC->AHB1ENR|=RCC_AHB1ENR_GPIOBEN; //enable gpiob clock
		RCC->APB1ENR|=RCC_APB1ENR_I2C1EN; //enable i2c1 clock

		//set PB6 and PB9 to alternative function
		GPIOB->MODER|=GPIO_MODER_MODE6_1|GPIO_MODER_MODE9_1;
		GPIOB->MODER&=~(GPIO_MODER_MODE6_0|GPIO_MODER_MODE9_0);

		GPIOB->AFR[0]|=(I2C1_AF<<GPIO_AFRL_AFSEL6_Pos);

		GPIOB->AFR[1]|=(I2C1_AF<<GPIO_AFRH_AFSEL9_Pos);

		GPIOB->OTYPER|=GPIO_OTYPER_OT6|GPIO_OTYPER_OT9; //set pb8 and pb9 as open drain

		I2C1->CR1=I2C_CR1_SWRST;

		I2C1->CR1&=~I2C_CR1_SWRST;

		I2C1->CR2|=50;

		I2C1->CCR=0xd2;

		I2C1->TRISE=0x2b; //output max rise

		I2C1->CR1|=I2C_CR1_PE;

		inited=1;
	}
}
char i2c_readByte(char saddr,char maddr, char *data)
{


	while(I2C1->SR2&I2C_SR2_BUSY){;}
	I2C1->CR1|=I2C_CR1_START;
	while(!(I2C1->SR1&I2C_SR1_SB)){;}
	I2C1->DR=saddr<<1;
	while(!(I2C1->SR1&I2C_SR1_ADDR)){;}
	(void)I2C1->SR2;
	while(!(I2C1->SR1&I2C_SR1_TXE)){;}
	I2C1->DR=maddr;
	while(!(I2C1->SR1&I2C_SR1_TXE)){;}
	I2C1->CR1|=I2C_CR1_START;
	while(!(I2C1->SR1&I2C_SR1_SB)){;}
	I2C1->DR=saddr<<1|1;
	while(!(I2C1->SR1&I2C_SR1_ADDR)){;}
	I2C1->CR1&=~I2C_CR1_ACK;
	(void)I2C1->SR2;
	I2C1->CR1|=I2C_CR1_STOP;
	while(!(I2C1->SR1&I2C_SR1_RXNE)){;}
	*data++=I2C1->DR;
	return 0;
}

void i2c_writeByte(char saddr,char maddr,char data)
{



	while(I2C1->SR2&I2C_SR2_BUSY){;}          /*wait until bus not busy*/
	I2C1->CR1|=I2C_CR1_START;                 /*generate start*/
	while(!(I2C1->SR1&I2C_SR1_SB)){;}         /*wait until start bit is set*/
	I2C1->DR = saddr<< 1;                 	 /* Send slave address*/
	while(!(I2C1->SR1&I2C_SR1_ADDR)){;}      /*wait until address flag is set*/
	(void)I2C1->SR2; 											 /*clear SR2 by reading it */
	while(!(I2C1->SR1&I2C_SR1_TXE)){;}       /*Wait until Data register empty*/
	I2C1->DR = maddr;                        /* send memory address*/
	while(!(I2C1->SR1&I2C_SR1_TXE)){;}       /*wait until data register empty*/
	I2C1->DR = data;
	while (!(I2C1->SR1 & I2C_SR1_BTF));      /*wait until transfer finished*/
	I2C1->CR1 |=I2C_CR1_STOP;								 /*Generate Stop*/

}

void i2c_WriteMulti(char saddr,char maddr,char *buffer, uint8_t length)
{

	while (I2C1->SR2 & I2C_SR2_BUSY);           //wait until bus not busy
	I2C1->CR1 |= I2C_CR1_START;                   //generate start
	while (!(I2C1->SR1 & I2C_SR1_SB)){;}					//wait until start is generated
	I2C1->DR = saddr<< 1;                 	 			// Send slave address
	while (!(I2C1->SR1 & I2C_SR1_ADDR)){;}        //wait until address flag is set
	(void) I2C1->SR2; 						      //Clear SR2
	while (!(I2C1->SR1 & I2C_SR1_TXE));           //Wait until Data register empty
	I2C1->DR = maddr;                      				// send memory address
	while (!(I2C1->SR1 & I2C_SR1_TXE));           //wait until data register empty
	//sending the data
	for (uint8_t i=0;i<length;i++)
	 {
	 I2C1->DR=buffer[i]; 													//filling buffer with command or data
		while (!(I2C1->SR1 & I2C_SR1_BTF));
	 }

	I2C1->CR1 |= I2C_CR1_STOP;										//wait until transfer finished
}


void i2c_ReadMulti(char saddr,char maddr, int n, char* data)
{

	while (I2C1->SR2 & I2C_SR2_BUSY){;}
	I2C1->CR1|=I2C_CR1_START;
	while(!(I2C1->SR1 & I2C_SR1_SB)){;}
	I2C1->DR=saddr<<1;
	while(!(I2C1->SR1 & I2C_SR1_ADDR)){;}
	(void)I2C1->SR2;
	while(!(I2C1->SR1&I2C_SR1_TXE)){;}
	I2C1->DR = maddr;
	while(!(I2C1->SR1&I2C_SR1_TXE)){;}
	I2C1->CR1|=I2C_CR1_START;
	while(!(I2C1->SR1 & I2C_SR1_SB)){;}
	I2C1->DR=saddr<<1|1;
	while(!(I2C1->SR1 & I2C_SR1_ADDR)){;}
	(void)I2C1->SR2;
	I2C1->CR1|=I2C_CR1_ACK;
	while(n>0U)
		{
		if(n==1U)
				{
				I2C1->CR1&=~I2C_CR1_ACK;
					I2C1->CR1|=I2C_CR1_STOP;
					while(!(I2C1->SR1&I2C_SR1_RXNE)){;}
					*data++=I2C1->DR;
						break;
				}
			else
					{

					while(!(I2C1->SR1&I2C_SR1_RXNE)){;}
						(*data++)=I2C1->DR;
							n--;
				}
}
}