RaDrone/Source/BSP/Src/imu.c

#include "imu.h"

void imu_pow_init()
{
	RCC->AHB2ENR |= RCC_AHB2ENR_GPIOCEN;
	GPIOC->MODER &= ~(3 << (13 * 2));
	GPIOC->MODER |= 1 << (13 * 2);
	GPIOC->OTYPER &= ~(1 << 13);
	GPIOC->PUPDR &= ~(3 << (13 * 2));
	GPIOC->BSRR = 1 << (13 + 16);
}

void i2c_gpio_init()
{
	// enable GPIOB clock
	RCC->AHB2ENR |= RCC_AHB2ENR_GPIOBEN;
	
	// Alt function mode PB8, PB9
	GPIOB->MODER &=  ~((3 << 8 * 2) | (3 << 9 * 2));
	GPIOB->MODER |= (2 << (8 * 2)) | (2 << (9 * 2));
	
	// select AF4 for I2C1 at PB8 and PB9
	GPIOB->AFR[1] &= ~((0xF << ((8 - 8) * 4)) | (0xF << ((9 - 8) * 4)));
	GPIOB->AFR[1] |= ((4 << ((8 - 8) * 4)) | (4 << ((9 - 8) * 4)));
	
  // high speed
  GPIOB->OSPEEDR |= (2 << (8 * 2)) | (2 << (9 * 2));
  
	// enable open-drain
	GPIOB->OTYPER |= (1 << 8) | (1 << 9);
	
	// set pull-up
	GPIOB->PUPDR &= ~((3 << (8 * 2)) | (3 << (9 * 2)));
	GPIOB->PUPDR |= (1 << 8 * 2) | (1 << 9 * 2);
}

void i2c1_init()
{
	
	RCC->APB1ENR1 |= RCC_APB1ENR1_I2C1EN; // enable I2C1
	
	I2C1->TIMINGR = 0x10802D9BUL;         // 400 kHz @ 16 MHz
	
  I2C1->CR1 |= I2C_CR1_PE;
}

void imu_init()
{
	// select bank 0
	i2c_write(ICM_ADDR, REG_BANK_SEL, ~(3 << 4));
	
	// wake up, auto clock
	i2c_write(ICM_ADDR, REG_PWR_MGMT_1, 1);
	
	// select bank 2
	i2c_write(ICM_ADDR, REG_BANK_SEL, 2 << 4);
	
	// gyro ~2000 dps, FS_SEL = 3
	i2c_write(ICM_ADDR, REG_GYRO_CONFIG_1, GYRO_FS_SEL_2000 | GYRO_DLPFCFG_73 | GYRO_FCHOICE_ON);
	
	// accel 8g, FS_SEL = 2
	i2c_write(ICM_ADDR, REG_ACCEL_CONFIG, ACCEL_FS_SEL_8 | ACCEL_DLPFCFG_69 | ACCEL_FCHOICE_ON);
	
	// back to bank 0
	i2c_write(ICM_ADDR, REG_BANK_SEL, ~(3 << 4));
}

void imu_tim6_init(const uint16_t freq)
{
	RCC->APB1ENR1 |= RCC_APB1ENR1_TIM6EN;
	
  TIM6->CR1 = 0;
  TIM6->ARR = 1000 - 1;
	TIM6->PSC = (SystemCoreClock / 1000 / freq) - 1;
		
	TIM6->DIER |= TIM_DIER_UIE;   // interrupt enable
	TIM6->CR1 |= TIM_CR1_CEN;     // counter enable
	
	NVIC_EnableIRQ(TIM6_DAC_IRQn);
}

void i2c_read(uint8_t addr, uint8_t reg, uint8_t* buf, uint8_t len)
{
	i2c_wait_idle(I2C1);
	
	// write register address
	I2C1->CR2 = (addr << 1) | (1 << I2C_CR2_NBYTES_Pos) | I2C_CR2_START;
	
	while (!(I2C1->ISR & I2C_ISR_TXIS));
	I2C1->TXDR = reg;
	
	while (!(I2C1->ISR & I2C_ISR_TC));
	
	I2C1->CR2 = (addr << 1) | I2C_CR2_RD_WRN | (len << I2C_CR2_NBYTES_Pos) | I2C_CR2_AUTOEND | I2C_CR2_START;
	
	for (uint8_t i = 0; i < len; ++i)
	{
		while (!(I2C1->ISR & I2C_ISR_RXNE));
		buf[i] = I2C1->RXDR;
	}
	
	while (!(I2C1->ISR & I2C_ISR_STOPF));
	I2C1->ICR |= I2C_ICR_STOPCF;
}

uint8_t i2c_read_async(uint8_t addr, uint8_t reg, uint8_t len, void (*cb)(uint8_t*))
{
	if (i2c_busy) return 0;

	i2c_busy = 1;

	i2c_addr = addr;
	i2c_reg = reg;
	i2c_len = len;
	i2c_callback = cb;
  
  // включаем прерывания
	I2C1->CR1 |= I2C_CR1_TXIE | I2C_CR1_RXIE | I2C_CR1_TCIE | I2C_CR1_STOPIE;
  NVIC_EnableIRQ(I2C1_EV_IRQn);

	// старт записи регистра
	I2C1->CR2 = (addr << 1) | (1 << I2C_CR2_NBYTES_Pos) | I2C_CR2_START;

	return 1;
}

void i2c_write(uint8_t addr, uint8_t reg, uint8_t data)
{
	i2c_wait_idle(I2C1);
	
	// write register address
	I2C1->CR2 = (addr << 1) | (2 << I2C_CR2_NBYTES_Pos) | I2C_CR2_START;
	
	while (!(I2C1->ISR & I2C_ISR_TXIS));
	I2C1->TXDR = reg;
	
	while (!(I2C1->ISR & I2C_ISR_TXIS));
	I2C1->TXDR = data;
	
	while (!(I2C1->ISR & I2C_ISR_TC));
	I2C1->CR2 |= I2C_CR2_STOP;
}

void I2C1_EV_IRQHandler()
{
	static uint8_t index = 0;
	static uint8_t stage = 0; // 0 = send reg, 1 = read

	// TX — отправляем регистр
	if (I2C1->ISR & I2C_ISR_TXIS)
	{
		I2C1->TXDR = i2c_reg;
	}

	// переход к чтению
	if (I2C1->ISR & I2C_ISR_TC)
	{
		I2C1->CR2 = (i2c_addr << 1) |
		            I2C_CR2_RD_WRN |
		            (i2c_len << I2C_CR2_NBYTES_Pos) |
		            I2C_CR2_AUTOEND |
		            I2C_CR2_START;

		index = 0;
		stage = 1;
	}

	// чтение данных
	if (I2C1->ISR & I2C_ISR_RXNE)
	{
		i2c_buf[index++] = I2C1->RXDR;
	}

	// завершение
	if (I2C1->ISR & I2C_ISR_STOPF)
	{
		I2C1->ICR |= I2C_ICR_STOPCF;

		i2c_busy = 0;
    
    // отключаем IRQ
    I2C1->CR1 &= ~(I2C_CR1_TXIE | I2C_CR1_RXIE | I2C_CR1_TCIE | I2C_CR1_STOPIE);

		if (i2c_callback)
			i2c_callback(i2c_buf);
	}
}

void imu_read_raw(imu_raw_t* data)
{
	uint8_t buf[12];
	
	i2c_read(ICM_ADDR, 0x2D, buf, 12);
	
	data->ax = (buf[0] << 8) | buf[1];
	data->ay = (buf[2] << 8) | buf[3];
	data->az = (buf[4] << 8) | buf[5];
	
	data->gx = (buf[6] << 8)  | buf[7];
	data->gy = (buf[8] << 8)  | buf[9];
	data->gz = (buf[10] << 8) | buf[11];
}

static void i2c_wait_idle(I2C_TypeDef* i2c)
{
  int timeout = 100000;
  while ((i2c->ISR & I2C_ISR_BUSY) && --timeout);

  if (timeout == 0)
  {
    // сброс I2C
    i2c->CR1 &= ~I2C_CR1_PE;
    i2c->CR1 |= I2C_CR1_PE;
  }
  
	// while (i2c->ISR & I2C_ISR_BUSY);
	
	i2c->ICR = I2C_ICR_STOPCF |
           I2C_ICR_NACKCF |
           I2C_ICR_BERRCF |
           I2C_ICR_ARLOCF;
}