mirror of
https://gitee.com/Lyon1998/pikapython.git
synced 2025-01-22 17:12:55 +08:00
884 lines
31 KiB
C
884 lines
31 KiB
C
/********************************** (C) COPYRIGHT *******************************
|
|
* File Name : ch32v10x_i2c.c
|
|
* Author : WCH
|
|
* Version : V1.0.0
|
|
* Date : 2020/04/30
|
|
* Description : This file provides all the I2C firmware functions.
|
|
*******************************************************************************/
|
|
#include "ch32v10x_i2c.h"
|
|
#include "ch32v10x_rcc.h"
|
|
|
|
/* I2C SPE mask */
|
|
#define CTLR1_PE_Set ((uint16_t)0x0001)
|
|
#define CTLR1_PE_Reset ((uint16_t)0xFFFE)
|
|
|
|
/* I2C START mask */
|
|
#define CTLR1_START_Set ((uint16_t)0x0100)
|
|
#define CTLR1_START_Reset ((uint16_t)0xFEFF)
|
|
|
|
/* I2C STOP mask */
|
|
#define CTLR1_STOP_Set ((uint16_t)0x0200)
|
|
#define CTLR1_STOP_Reset ((uint16_t)0xFDFF)
|
|
|
|
/* I2C ACK mask */
|
|
#define CTLR1_ACK_Set ((uint16_t)0x0400)
|
|
#define CTLR1_ACK_Reset ((uint16_t)0xFBFF)
|
|
|
|
/* I2C ENGC mask */
|
|
#define CTLR1_ENGC_Set ((uint16_t)0x0040)
|
|
#define CTLR1_ENGC_Reset ((uint16_t)0xFFBF)
|
|
|
|
/* I2C SWRST mask */
|
|
#define CTLR1_SWRST_Set ((uint16_t)0x8000)
|
|
#define CTLR1_SWRST_Reset ((uint16_t)0x7FFF)
|
|
|
|
/* I2C PEC mask */
|
|
#define CTLR1_PEC_Set ((uint16_t)0x1000)
|
|
#define CTLR1_PEC_Reset ((uint16_t)0xEFFF)
|
|
|
|
/* I2C ENPEC mask */
|
|
#define CTLR1_ENPEC_Set ((uint16_t)0x0020)
|
|
#define CTLR1_ENPEC_Reset ((uint16_t)0xFFDF)
|
|
|
|
/* I2C ENARP mask */
|
|
#define CTLR1_ENARP_Set ((uint16_t)0x0010)
|
|
#define CTLR1_ENARP_Reset ((uint16_t)0xFFEF)
|
|
|
|
/* I2C NOSTRETCH mask */
|
|
#define CTLR1_NOSTRETCH_Set ((uint16_t)0x0080)
|
|
#define CTLR1_NOSTRETCH_Reset ((uint16_t)0xFF7F)
|
|
|
|
/* I2C registers Masks */
|
|
#define CTLR1_CLEAR_Mask ((uint16_t)0xFBF5)
|
|
|
|
/* I2C DMAEN mask */
|
|
#define CTLR2_DMAEN_Set ((uint16_t)0x0800)
|
|
#define CTLR2_DMAEN_Reset ((uint16_t)0xF7FF)
|
|
|
|
/* I2C LAST mask */
|
|
#define CTLR2_LAST_Set ((uint16_t)0x1000)
|
|
#define CTLR2_LAST_Reset ((uint16_t)0xEFFF)
|
|
|
|
/* I2C FREQ mask */
|
|
#define CTLR2_FREQ_Reset ((uint16_t)0xFFC0)
|
|
|
|
/* I2C ADD0 mask */
|
|
#define OADDR1_ADD0_Set ((uint16_t)0x0001)
|
|
#define OADDR1_ADD0_Reset ((uint16_t)0xFFFE)
|
|
|
|
/* I2C ENDUAL mask */
|
|
#define OADDR2_ENDUAL_Set ((uint16_t)0x0001)
|
|
#define OADDR2_ENDUAL_Reset ((uint16_t)0xFFFE)
|
|
|
|
/* I2C ADD2 mask */
|
|
#define OADDR2_ADD2_Reset ((uint16_t)0xFF01)
|
|
|
|
/* I2C F/S mask */
|
|
#define CKCFGR_FS_Set ((uint16_t)0x8000)
|
|
|
|
/* I2C CCR mask */
|
|
#define CKCFGR_CCR_Set ((uint16_t)0x0FFF)
|
|
|
|
/* I2C FLAG mask */
|
|
#define FLAG_Mask ((uint32_t)0x00FFFFFF)
|
|
|
|
/* I2C Interrupt Enable mask */
|
|
#define ITEN_Mask ((uint32_t)0x07000000)
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_DeInit
|
|
* Description : Deinitializes the I2Cx peripheral registers to their default
|
|
* reset values.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_DeInit(I2C_TypeDef* I2Cx)
|
|
{
|
|
if (I2Cx == I2C1)
|
|
{
|
|
RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE);
|
|
RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, DISABLE);
|
|
}
|
|
else
|
|
{
|
|
RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C2, ENABLE);
|
|
RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C2, DISABLE);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_Init
|
|
* Description : Initializes the I2Cx peripheral according to the specified
|
|
* parameters in the I2C_InitStruct.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* I2C_InitStruct: pointer to a I2C_InitTypeDef structure that
|
|
* contains the configuration information for the specified I2C peripheral.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_Init(I2C_TypeDef* I2Cx, I2C_InitTypeDef* I2C_InitStruct)
|
|
{
|
|
uint16_t tmpreg = 0, freqrange = 0;
|
|
uint16_t result = 0x04;
|
|
uint32_t pclk1 = 8000000;
|
|
|
|
RCC_ClocksTypeDef rcc_clocks;
|
|
|
|
tmpreg = I2Cx->CTLR2;
|
|
tmpreg &= CTLR2_FREQ_Reset;
|
|
RCC_GetClocksFreq(&rcc_clocks);
|
|
pclk1 = rcc_clocks.PCLK1_Frequency;
|
|
freqrange = (uint16_t)(pclk1 / 1000000);
|
|
tmpreg |= freqrange;
|
|
I2Cx->CTLR2 = tmpreg;
|
|
|
|
I2Cx->CTLR1 &= CTLR1_PE_Reset;
|
|
tmpreg = 0;
|
|
|
|
if (I2C_InitStruct->I2C_ClockSpeed <= 100000)
|
|
{
|
|
result = (uint16_t)(pclk1 / (I2C_InitStruct->I2C_ClockSpeed << 1));
|
|
|
|
if (result < 0x04)
|
|
{
|
|
result = 0x04;
|
|
}
|
|
|
|
tmpreg |= result;
|
|
I2Cx->RTR = freqrange + 1;
|
|
}
|
|
else
|
|
{
|
|
if (I2C_InitStruct->I2C_DutyCycle == I2C_DutyCycle_2)
|
|
{
|
|
result = (uint16_t)(pclk1 / (I2C_InitStruct->I2C_ClockSpeed * 3));
|
|
}
|
|
else
|
|
{
|
|
result = (uint16_t)(pclk1 / (I2C_InitStruct->I2C_ClockSpeed * 25));
|
|
result |= I2C_DutyCycle_16_9;
|
|
}
|
|
|
|
if ((result & CKCFGR_CCR_Set) == 0)
|
|
{
|
|
result |= (uint16_t)0x0001;
|
|
}
|
|
|
|
tmpreg |= (uint16_t)(result | CKCFGR_FS_Set);
|
|
I2Cx->RTR = (uint16_t)(((freqrange * (uint16_t)300) / (uint16_t)1000) + (uint16_t)1);
|
|
}
|
|
|
|
I2Cx->CKCFGR = tmpreg;
|
|
I2Cx->CTLR1 |= CTLR1_PE_Set;
|
|
|
|
|
|
tmpreg = I2Cx->CTLR1;
|
|
tmpreg &= CTLR1_CLEAR_Mask;
|
|
tmpreg |= (uint16_t)((uint32_t)I2C_InitStruct->I2C_Mode | I2C_InitStruct->I2C_Ack);
|
|
I2Cx->CTLR1 = tmpreg;
|
|
|
|
I2Cx->OADDR1 = (I2C_InitStruct->I2C_AcknowledgedAddress | I2C_InitStruct->I2C_OwnAddress1);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_StructInit
|
|
* Description : Fills each I2C_InitStruct member with its default value.
|
|
* Input : I2C_InitStruct: pointer to an I2C_InitTypeDef structure which
|
|
* will be initialized.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_StructInit(I2C_InitTypeDef* I2C_InitStruct)
|
|
{
|
|
I2C_InitStruct->I2C_ClockSpeed = 5000;
|
|
I2C_InitStruct->I2C_Mode = I2C_Mode_I2C;
|
|
I2C_InitStruct->I2C_DutyCycle = I2C_DutyCycle_2;
|
|
I2C_InitStruct->I2C_OwnAddress1 = 0;
|
|
I2C_InitStruct->I2C_Ack = I2C_Ack_Disable;
|
|
I2C_InitStruct->I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_Cmd
|
|
* Description : Enables or disables the specified I2C peripheral.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* NewState: ENABLE or DISABLE.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_Cmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
|
|
{
|
|
if (NewState != DISABLE)
|
|
{
|
|
I2Cx->CTLR1 |= CTLR1_PE_Set;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR1 &= CTLR1_PE_Reset;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_DMACmd
|
|
* Description : Enables or disables the specified I2C DMA requests.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* NewState: ENABLE or DISABLE.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_DMACmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
|
|
{
|
|
if (NewState != DISABLE)
|
|
{
|
|
I2Cx->CTLR2 |= CTLR2_DMAEN_Set;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR2 &= CTLR2_DMAEN_Reset;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_DMALastTransferCmd
|
|
* Description : Specifies if the next DMA transfer will be the last one.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* NewState: ENABLE or DISABLE.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_DMALastTransferCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
|
|
{
|
|
if (NewState != DISABLE)
|
|
{
|
|
I2Cx->CTLR2 |= CTLR2_LAST_Set;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR2 &= CTLR2_LAST_Reset;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_GenerateSTART
|
|
* Description : Generates I2Cx communication START condition.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* NewState: ENABLE or DISABLE.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_GenerateSTART(I2C_TypeDef* I2Cx, FunctionalState NewState)
|
|
{
|
|
if (NewState != DISABLE)
|
|
{
|
|
I2Cx->CTLR1 |= CTLR1_START_Set;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR1 &= CTLR1_START_Reset;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_GenerateSTOP
|
|
* Description : Generates I2Cx communication STOP condition.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* NewState: ENABLE or DISABLE.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_GenerateSTOP(I2C_TypeDef* I2Cx, FunctionalState NewState)
|
|
{
|
|
if (NewState != DISABLE)
|
|
{
|
|
I2Cx->CTLR1 |= CTLR1_STOP_Set;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR1 &= CTLR1_STOP_Reset;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_AcknowledgeConfig
|
|
* Description : Enables or disables the specified I2C acknowledge feature.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* NewState: ENABLE or DISABLE.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_AcknowledgeConfig(I2C_TypeDef* I2Cx, FunctionalState NewState)
|
|
{
|
|
if (NewState != DISABLE)
|
|
{
|
|
I2Cx->CTLR1 |= CTLR1_ACK_Set;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR1 &= CTLR1_ACK_Reset;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_OwnAddress2Config
|
|
* Description : Configures the specified I2C own address2.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* Address: specifies the 7bit I2C own address2.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_OwnAddress2Config(I2C_TypeDef* I2Cx, uint8_t Address)
|
|
{
|
|
uint16_t tmpreg = 0;
|
|
|
|
tmpreg = I2Cx->OADDR2;
|
|
tmpreg &= OADDR2_ADD2_Reset;
|
|
tmpreg |= (uint16_t)((uint16_t)Address & (uint16_t)0x00FE);
|
|
I2Cx->OADDR2 = tmpreg;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_DualAddressCmd
|
|
* Description : Enables or disables the specified I2C dual addressing mode.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* NewState: ENABLE or DISABLE.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_DualAddressCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
|
|
{
|
|
if (NewState != DISABLE)
|
|
{
|
|
I2Cx->OADDR2 |= OADDR2_ENDUAL_Set;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->OADDR2 &= OADDR2_ENDUAL_Reset;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_GeneralCallCmd
|
|
* Description : Enables or disables the specified I2C general call feature.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* NewState: ENABLE or DISABLE.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_GeneralCallCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
|
|
{
|
|
if (NewState != DISABLE)
|
|
{
|
|
I2Cx->CTLR1 |= CTLR1_ENGC_Set;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR1 &= CTLR1_ENGC_Reset;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_ITConfig
|
|
* Description : Enables or disables the specified I2C interrupts.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* I2C_IT: specifies the I2C interrupts sources to be enabled or disabled.
|
|
* I2C_IT_BUF: Buffer interrupt mask.
|
|
* I2C_IT_EVT: Event interrupt mask.
|
|
* I2C_IT_ERR: Error interrupt mask.
|
|
* NewState: ENABLE or DISABLE.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_ITConfig(I2C_TypeDef* I2Cx, uint16_t I2C_IT, FunctionalState NewState)
|
|
{
|
|
if (NewState != DISABLE)
|
|
{
|
|
I2Cx->CTLR2 |= I2C_IT;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR2 &= (uint16_t)~I2C_IT;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_SendData
|
|
* Description : Sends a data byte through the I2Cx peripheral.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* Data: Byte to be transmitted.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_SendData(I2C_TypeDef* I2Cx, uint8_t Data)
|
|
{
|
|
I2Cx->DATAR = Data;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_ReceiveData
|
|
* Description : Returns the most recent received data by the I2Cx peripheral.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* Return : The value of the received data.
|
|
*******************************************************************************/
|
|
uint8_t I2C_ReceiveData(I2C_TypeDef* I2Cx)
|
|
{
|
|
return (uint8_t)I2Cx->DATAR;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_Send7bitAddress
|
|
* Description : Transmits the address byte to select the slave device.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* Address: specifies the slave address which will be transmitted.
|
|
* I2C_Direction: specifies whether the I2C device will be a
|
|
* Transmitter or a Receiver.
|
|
* I2C_Direction_Transmitter: Transmitter mode.
|
|
* I2C_Direction_Receiver: Receiver mode.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_Send7bitAddress(I2C_TypeDef* I2Cx, uint8_t Address, uint8_t I2C_Direction)
|
|
{
|
|
if (I2C_Direction != I2C_Direction_Transmitter)
|
|
{
|
|
Address |= OADDR1_ADD0_Set;
|
|
}
|
|
else
|
|
{
|
|
Address &= OADDR1_ADD0_Reset;
|
|
}
|
|
|
|
I2Cx->DATAR = Address;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_ReadRegister
|
|
* Description : Reads the specified I2C register and returns its value.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* I2C_Register: specifies the register to read.
|
|
* I2C_Register_CTLR1.
|
|
* I2C_Register_CTLR2.
|
|
* I2C_Register_OADDR1.
|
|
* I2C_Register_OADDR2.
|
|
* I2C_Register_DATAR.
|
|
* I2C_Register_STAR1.
|
|
* I2C_Register_STAR2.
|
|
* I2C_Register_CKCFGR.
|
|
* I2C_Register_RTR.
|
|
* Return : The value of the received data.
|
|
*******************************************************************************/
|
|
uint16_t I2C_ReadRegister(I2C_TypeDef* I2Cx, uint8_t I2C_Register)
|
|
{
|
|
__IO uint32_t tmp = 0;
|
|
|
|
tmp = (uint32_t) I2Cx;
|
|
tmp += I2C_Register;
|
|
|
|
return (*(__IO uint16_t *) tmp);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_SoftwareResetCmd
|
|
* Description : Enables or disables the specified I2C software reset.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* NewState: ENABLE or DISABLE.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_SoftwareResetCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
|
|
{
|
|
if (NewState != DISABLE)
|
|
{
|
|
I2Cx->CTLR1 |= CTLR1_SWRST_Set;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR1 &= CTLR1_SWRST_Reset;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_NACKPositionConfig
|
|
* Description : Selects the specified I2C NACK position in master receiver mode.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* I2C_NACKPosition: specifies the NACK position.
|
|
* I2C_NACKPosition_Next: indicates that the next byte will be
|
|
* the last received byte.
|
|
* I2C_NACKPosition_Current: indicates that current byte is the
|
|
* last received byte.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_NACKPositionConfig(I2C_TypeDef* I2Cx, uint16_t I2C_NACKPosition)
|
|
{
|
|
if (I2C_NACKPosition == I2C_NACKPosition_Next)
|
|
{
|
|
I2Cx->CTLR1 |= I2C_NACKPosition_Next;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR1 &= I2C_NACKPosition_Current;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_SMBusAlertConfig
|
|
* Description : Drives the SMBusAlert pin high or low for the specified I2C.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* I2C_SMBusAlert: specifies SMBAlert pin level.
|
|
* I2C_SMBusAlert_Low: SMBAlert pin driven low.
|
|
* I2C_SMBusAlert_High: SMBAlert pin driven high.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_SMBusAlertConfig(I2C_TypeDef* I2Cx, uint16_t I2C_SMBusAlert)
|
|
{
|
|
if (I2C_SMBusAlert == I2C_SMBusAlert_Low)
|
|
{
|
|
I2Cx->CTLR1 |= I2C_SMBusAlert_Low;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR1 &= I2C_SMBusAlert_High;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_TransmitPEC
|
|
* Description : Enables or disables the specified I2C PEC transfer.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* NewState: ENABLE or DISABLE.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_TransmitPEC(I2C_TypeDef* I2Cx, FunctionalState NewState)
|
|
{
|
|
if (NewState != DISABLE)
|
|
{
|
|
I2Cx->CTLR1 |= CTLR1_PEC_Set;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR1 &= CTLR1_PEC_Reset;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_PECPositionConfig
|
|
* Description : Selects the specified I2C PEC position.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* I2C_PECPosition: specifies the PEC position.
|
|
* I2C_PECPosition_Next: indicates that the next byte is PEC.
|
|
* I2C_PECPosition_Current: indicates that current byte is PEC.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_PECPositionConfig(I2C_TypeDef* I2Cx, uint16_t I2C_PECPosition)
|
|
{
|
|
if (I2C_PECPosition == I2C_PECPosition_Next)
|
|
{
|
|
I2Cx->CTLR1 |= I2C_PECPosition_Next;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR1 &= I2C_PECPosition_Current;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_CalculatePEC
|
|
* Description : Enables or disables the PEC value calculation of the transferred bytes.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* NewState: ENABLE or DISABLE.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_CalculatePEC(I2C_TypeDef* I2Cx, FunctionalState NewState)
|
|
{
|
|
if (NewState != DISABLE)
|
|
{
|
|
I2Cx->CTLR1 |= CTLR1_ENPEC_Set;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR1 &= CTLR1_ENPEC_Reset;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_GetPEC
|
|
* Description : Returns the PEC value for the specified I2C.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* Return : The PEC value.
|
|
*******************************************************************************/
|
|
uint8_t I2C_GetPEC(I2C_TypeDef* I2Cx)
|
|
{
|
|
return ((I2Cx->STAR2) >> 8);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_ARPCmd
|
|
* Description : Enables or disables the specified I2C ARP.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* NewState: ENABLE or DISABLE.
|
|
* Return : The PEC value.
|
|
*******************************************************************************/
|
|
void I2C_ARPCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
|
|
{
|
|
if (NewState != DISABLE)
|
|
{
|
|
I2Cx->CTLR1 |= CTLR1_ENARP_Set;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR1 &= CTLR1_ENARP_Reset;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_StretchClockCmd
|
|
* Description : Enables or disables the specified I2C Clock stretching.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* NewState: ENABLE or DISABLE.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_StretchClockCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
|
|
{
|
|
if (NewState == DISABLE)
|
|
{
|
|
I2Cx->CTLR1 |= CTLR1_NOSTRETCH_Set;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CTLR1 &= CTLR1_NOSTRETCH_Reset;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_FastModeDutyCycleConfig
|
|
* Description : Selects the specified I2C fast mode duty cycle.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* I2C_DutyCycle: specifies the fast mode duty cycle.
|
|
* I2C_DutyCycle_2: I2C fast mode Tlow/Thigh = 2.
|
|
* I2C_DutyCycle_16_9: I2C fast mode Tlow/Thigh = 16/9.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_FastModeDutyCycleConfig(I2C_TypeDef* I2Cx, uint16_t I2C_DutyCycle)
|
|
{
|
|
if (I2C_DutyCycle != I2C_DutyCycle_16_9)
|
|
{
|
|
I2Cx->CKCFGR &= I2C_DutyCycle_2;
|
|
}
|
|
else
|
|
{
|
|
I2Cx->CKCFGR |= I2C_DutyCycle_16_9;
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_CheckEvent
|
|
* Description : Checks whether the last I2Cx Event is equal to the one passed
|
|
* as parameter.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* I2C_EVENT: specifies the event to be checked.
|
|
* I2C_EVENT_SLAVE_TRANSMITTER_ADDRESS_MATCHED : EV1.
|
|
* I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED : EV1.
|
|
* I2C_EVENT_SLAVE_TRANSMITTER_SECONDADDRESS_MATCHED : EV1.
|
|
* I2C_EVENT_SLAVE_RECEIVER_SECONDADDRESS_MATCHED : EV1.
|
|
* I2C_EVENT_SLAVE_GENERALCALLADDRESS_MATCHED : EV1.
|
|
* I2C_EVENT_SLAVE_BYTE_RECEIVED : EV2.
|
|
* (I2C_EVENT_SLAVE_BYTE_RECEIVED | I2C_FLAG_DUALF) : EV2.
|
|
* (I2C_EVENT_SLAVE_BYTE_RECEIVED | I2C_FLAG_GENCALL) : EV2.
|
|
* I2C_EVENT_SLAVE_BYTE_TRANSMITTED : EV3.
|
|
* (I2C_EVENT_SLAVE_BYTE_TRANSMITTED | I2C_FLAG_DUALF) : EV3.
|
|
* (I2C_EVENT_SLAVE_BYTE_TRANSMITTED | I2C_FLAG_GENCALL) : EV3.
|
|
* I2C_EVENT_SLAVE_ACK_FAILURE : EV3_2.
|
|
* I2C_EVENT_SLAVE_STOP_DETECTED : EV4.
|
|
* I2C_EVENT_MASTER_MODE_SELECT : EV5.
|
|
* I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED : EV6.
|
|
* I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED : EV6.
|
|
* I2C_EVENT_MASTER_BYTE_RECEIVED : EV7.
|
|
* I2C_EVENT_MASTER_BYTE_TRANSMITTING : EV8.
|
|
* I2C_EVENT_MASTER_BYTE_TRANSMITTED : EV8_2.
|
|
* I2C_EVENT_MASTER_MODE_ADDRESS10 : EV9.
|
|
* Return : ErrorStatus: SUCCESS or ERROR.
|
|
*******************************************************************************/
|
|
ErrorStatus I2C_CheckEvent(I2C_TypeDef* I2Cx, uint32_t I2C_EVENT)
|
|
{
|
|
uint32_t lastevent = 0;
|
|
uint32_t flag1 = 0, flag2 = 0;
|
|
ErrorStatus status = ERROR;
|
|
|
|
flag1 = I2Cx->STAR1;
|
|
flag2 = I2Cx->STAR2;
|
|
flag2 = flag2 << 16;
|
|
|
|
lastevent = (flag1 | flag2) & FLAG_Mask;
|
|
|
|
if ((lastevent & I2C_EVENT) == I2C_EVENT)
|
|
{
|
|
status = SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
status = ERROR;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_GetLastEvent
|
|
* Description : Returns the last I2Cx Event.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* Return : The last event.
|
|
*******************************************************************************/
|
|
uint32_t I2C_GetLastEvent(I2C_TypeDef* I2Cx)
|
|
{
|
|
uint32_t lastevent = 0;
|
|
uint32_t flag1 = 0, flag2 = 0;
|
|
|
|
flag1 = I2Cx->STAR1;
|
|
flag2 = I2Cx->STAR2;
|
|
flag2 = flag2 << 16;
|
|
lastevent = (flag1 | flag2) & FLAG_Mask;
|
|
|
|
return lastevent;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_GetFlagStatus
|
|
* Description : Checks whether the last I2Cx Event is equal to the one passed
|
|
* as parameter.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* I2C_FLAG: specifies the flag to check.
|
|
* I2C_FLAG_DUALF: Dual flag (Slave mode).
|
|
* I2C_FLAG_SMBHOST: SMBus host header (Slave mode).
|
|
* I2C_FLAG_SMBDEFAULT: SMBus default header (Slave mode).
|
|
* I2C_FLAG_GENCALL: General call header flag (Slave mode).
|
|
* I2C_FLAG_TRA: Transmitter/Receiver flag.
|
|
* I2C_FLAG_BUSY: Bus busy flag.
|
|
* I2C_FLAG_MSL: Master/Slave flag.
|
|
* I2C_FLAG_SMBALERT: SMBus Alert flag.
|
|
* I2C_FLAG_TIMEOUT: Timeout or Tlow error flag.
|
|
* I2C_FLAG_PECERR: PEC error in reception flag.
|
|
* I2C_FLAG_OVR: Overrun/Underrun flag (Slave mode).
|
|
* I2C_FLAG_AF: Acknowledge failure flag.
|
|
* I2C_FLAG_ARLO: Arbitration lost flag (Master mode).
|
|
* I2C_FLAG_BERR: Bus error flag.
|
|
* I2C_FLAG_TXE: Data register empty flag (Transmitter).
|
|
* I2C_FLAG_RXNE: Data register not empty (Receiver) flag.
|
|
* I2C_FLAG_STOPF: Stop detection flag (Slave mode).
|
|
* I2C_FLAG_ADD10: 10-bit header sent flag (Master mode).
|
|
* I2C_FLAG_BTF: Byte transfer finished flag.
|
|
* I2C_FLAG_ADDR: Address sent flag (Master mode) "ADSL"
|
|
* Address matched flag (Slave mode)"ENDA".
|
|
* I2C_FLAG_SB: Start bit flag (Master mode).
|
|
* Return : FlagStatus: SET or RESET.
|
|
*******************************************************************************/
|
|
FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG)
|
|
{
|
|
FlagStatus bitstatus = RESET;
|
|
__IO uint32_t i2creg = 0, i2cxbase = 0;
|
|
|
|
i2cxbase = (uint32_t)I2Cx;
|
|
i2creg = I2C_FLAG >> 28;
|
|
I2C_FLAG &= FLAG_Mask;
|
|
|
|
if(i2creg != 0)
|
|
{
|
|
i2cxbase += 0x14;
|
|
}
|
|
else
|
|
{
|
|
I2C_FLAG = (uint32_t)(I2C_FLAG >> 16);
|
|
i2cxbase += 0x18;
|
|
}
|
|
|
|
if(((*(__IO uint32_t *)i2cxbase) & I2C_FLAG) != (uint32_t)RESET)
|
|
{
|
|
bitstatus = SET;
|
|
}
|
|
else
|
|
{
|
|
bitstatus = RESET;
|
|
}
|
|
|
|
return bitstatus;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_ClearFlag
|
|
* Description : Clears the I2Cx's pending flags.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* I2C_FLAG: specifies the flag to clear.
|
|
* I2C_FLAG_SMBALERT: SMBus Alert flag.
|
|
* I2C_FLAG_TIMEOUT: Timeout or Tlow error flag.
|
|
* I2C_FLAG_PECERR: PEC error in reception flag.
|
|
* I2C_FLAG_OVR: Overrun/Underrun flag (Slave mode).
|
|
* I2C_FLAG_AF: Acknowledge failure flag.
|
|
* I2C_FLAG_ARLO: Arbitration lost flag (Master mode).
|
|
* I2C_FLAG_BERR: Bus error flag.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_ClearFlag(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG)
|
|
{
|
|
uint32_t flagpos = 0;
|
|
|
|
flagpos = I2C_FLAG & FLAG_Mask;
|
|
I2Cx->STAR1 = (uint16_t)~flagpos;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_GetITStatus
|
|
* Description : Checks whether the specified I2C interrupt has occurred or not.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* II2C_IT: specifies the interrupt source to check.
|
|
* I2C_IT_SMBALERT: SMBus Alert flag.
|
|
* I2C_IT_TIMEOUT: Timeout or Tlow error flag.
|
|
* I2C_IT_PECERR: PEC error in reception flag.
|
|
* I2C_IT_OVR: Overrun/Underrun flag (Slave mode).
|
|
* I2C_IT_AF: Acknowledge failure flag.
|
|
* I2C_IT_ARLO: Arbitration lost flag (Master mode).
|
|
* I2C_IT_BERR: Bus error flag.
|
|
* I2C_IT_TXE: Data register empty flag (Transmitter).
|
|
* I2C_IT_RXNE: Data register not empty (Receiver) flag.
|
|
* I2C_IT_STOPF: Stop detection flag (Slave mode).
|
|
* I2C_IT_ADD10: 10-bit header sent flag (Master mode).
|
|
* I2C_IT_BTF: Byte transfer finished flag.
|
|
* I2C_IT_ADDR: Address sent flag (Master mode) "ADSL" Address matched
|
|
* flag (Slave mode)"ENDAD".
|
|
* I2C_IT_SB: Start bit flag (Master mode).
|
|
* Return : None
|
|
*******************************************************************************/
|
|
ITStatus I2C_GetITStatus(I2C_TypeDef* I2Cx, uint32_t I2C_IT)
|
|
{
|
|
ITStatus bitstatus = RESET;
|
|
uint32_t enablestatus = 0;
|
|
|
|
enablestatus = (uint32_t)(((I2C_IT & ITEN_Mask) >> 16) & (I2Cx->CTLR2)) ;
|
|
I2C_IT &= FLAG_Mask;
|
|
|
|
if (((I2Cx->STAR1 & I2C_IT) != (uint32_t)RESET) && enablestatus)
|
|
{
|
|
bitstatus = SET;
|
|
}
|
|
else
|
|
{
|
|
bitstatus = RESET;
|
|
}
|
|
|
|
return bitstatus;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Function Name : I2C_ClearITPendingBit
|
|
* Description : Clears the I2Cx interrupt pending bits.
|
|
* Input : I2Cx: where x can be 1 or 2 to select the I2C peripheral.
|
|
* I2C_IT: specifies the interrupt pending bit to clear.
|
|
* I2C_IT_SMBALERT: SMBus Alert interrupt.
|
|
* I2C_IT_TIMEOUT: Timeout or Tlow error interrupt.
|
|
* I2C_IT_PECERR: PEC error in reception interrupt.
|
|
* I2C_IT_OVR: Overrun/Underrun interrupt (Slave mode).
|
|
* I2C_IT_AF: Acknowledge failure interrupt.
|
|
* I2C_IT_ARLO: Arbitration lost interrupt (Master mode).
|
|
* I2C_IT_BERR: Bus error interrupt.
|
|
* Return : None
|
|
*******************************************************************************/
|
|
void I2C_ClearITPendingBit(I2C_TypeDef* I2Cx, uint32_t I2C_IT)
|
|
{
|
|
uint32_t flagpos = 0;
|
|
|
|
flagpos = I2C_IT & FLAG_Mask;
|
|
I2Cx->STAR1 = (uint16_t)~flagpos;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|