OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [CORTEX_STM32F103_Keil/] [STM32F10xFWLib/] [src/] [stm32f10x_i2c.c] - Blame information for rev 600

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 582 jeremybenn 
/******************** (C) COPYRIGHT 2007 STMicroelectronics ********************
2 
* File Name          : stm32f10x_i2c.c
3 
* Author             : MCD Application Team
4 
* Date First Issued  : 09/29/2006
5 
* Description        : This file provides all the I2C firmware functions.
6 
********************************************************************************
7 
* History:
8 
* 04/02/2007: V0.2
9 
* 02/05/2007: V0.1
10 
* 09/29/2006: V0.01
11 
********************************************************************************
12 
* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
13 
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
14 
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
15 
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
16 
* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
17 
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
18 
*******************************************************************************/
19 
 
20 
/* Includes ------------------------------------------------------------------*/
21 
#include "stm32f10x_i2c.h"
22 
#include "stm32f10x_rcc.h"
23 
 
24 
/* Private typedef -----------------------------------------------------------*/
25 
/* Private define ------------------------------------------------------------*/
26 
/* I2C SPE mask */
27 
#define CR1_PE_Set              ((u16)0x0001)
28 
#define CR1_PE_Reset            ((u16)0xFFFE)
29 
 
30 
/* I2C DMAEN mask */
31 
#define CR2_DMAEN_Set           ((u16)0x0800)
32 
#define CR2_DMAEN_Reset         ((u16)0xF7FF)
33 
 
34 
/* I2C LAST mask */
35 
#define CR2_LAST_Set            ((u16)0x1000)
36 
#define CR2_LAST_Reset          ((u16)0xEFFF)
37 
 
38 
/* I2C START mask */
39 
#define CR1_START_Set           ((u16)0x0100)
40 
#define CR1_START_Reset         ((u16)0xFEFF)
41 
 
42 
/* I2C STOP mask */
43 
#define CR1_STOP_Set            ((u16)0x0200)
44 
#define CR1_STOP_Reset          ((u16)0xFDFF)
45 
 
46 
/* I2C ACK mask */
47 
#define CR1_ACK_Set             ((u16)0x0400)
48 
#define CR1_ACK_Reset           ((u16)0xFBFF)
49 
 
50 
/* I2C ENGC mask */
51 
#define CR1_ENGC_Set            ((u16)0x0040)
52 
#define CR1_ENGC_Reset          ((u16)0xFFBF)
53 
 
54 
/* I2C ADD0 mask */
55 
#define OAR1_ADD0_Set           ((u16)0x0001)
56 
#define OAR1_ADD0_Reset         ((u16)0xFFFE)
57 
 
58 
/* I2C SWRST mask */
59 
#define CR1_SWRST_Set           ((u16)0x8000)
60 
#define CR1_SWRST_Reset         ((u16)0x7FFF)
61 
 
62 
/* I2C PEC mask */
63 
#define CR1_PEC_Set             ((u16)0x1000)
64 
 
65 
/* I2C ENPEC mask */
66 
#define CR1_ENPEC_Set           ((u16)0x0020)
67 
#define CR1_ENPEC_Reset         ((u16)0xFFDF)
68 
 
69 
/* I2C ENARP mask */
70 
#define CR1_ENARP_Set           ((u16)0x0010)
71 
#define CR1_ENARP_Reset         ((u16)0xFFEF)
72 
 
73 
/* I2C NOSTRETCH mask */
74 
#define CR1_NOSTRETCH_Set       ((u16)0x0080)
75 
#define CR1_NOSTRETCH_Reset     ((u16)0xFF7F)
76 
 
77 
/* I2C ENDUAL mask */
78 
#define OAR2_ENDUAL_Set         ((u16)0x0001)
79 
#define OAR2_ENDUAL_Reset       ((u16)0xFFFE)
80 
 
81 
/* I2C F/S mask */
82 
#define CCR_FS_Set              ((u16)0x8000)
83 
 
84 
/* I2C ADD2 mask */
85 
#define OAR2_ADD2_Reset         ((u16)0xFF01)
86 
 
87 
/* I2C FREQ mask */
88 
#define CR2_FREQ_Reset          ((u16)0xFFC0)
89 
 
90 
/* I2C CCR mask */
91 
#define CCR_CCR_Set             ((u16)0x0FFF)
92 
 
93 
/* I2C FLAG mask */
94 
#define I2C_FLAG_Mask           ((u32)0x00FFFFFF)
95 
 
96 
/* I2C registers Masks */
97 
#define CR1_CLEAR_Mask          ((u16)0xFBF5)
98 
 
99 
/* Private macro -------------------------------------------------------------*/
100 
/* Private variables ---------------------------------------------------------*/
101 
/* Private function prototypes -----------------------------------------------*/
102 
/* Private functions ---------------------------------------------------------*/
103 
 
104 
/*******************************************************************************
105 
* Function Name  : I2C_DeInit
106 
* Description    : Deinitializes the I2Cx peripheral registers to their default
107 
*                  reset values.
108 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
109 
* Output         : None
110 
* Return         : None
111 
*******************************************************************************/
112 
void I2C_DeInit(I2C_TypeDef* I2Cx)
113 
{
114 
  switch (*(u32*)&I2Cx)
115 
  {
116 
    case I2C1_BASE:
117 
      /* Enable I2C1 reset state */
118 
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE);
119 
      /* Release I2C1 from reset state */
120 
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, DISABLE);
121 
      break;
122 
 
123 
    case I2C2_BASE:
124 
      /* Enable I2C2 reset state */
125 
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C2, ENABLE);
126 
      /* Release I2C2 from reset state */
127 
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C2, DISABLE);
128 
      break;
129 
 
130 
    default:
131 
      break;
132 
  }
133 
}
134 
 
135 
/*******************************************************************************
136 
* Function Name  : I2C_Init
137 
* Description    : Initializes the I2Cx according to the specified parameters
138 
*                  in the I2C_InitStruct.
139 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
140 
*                  - I2C_InitStruct: pointer to a I2C_InitTypeDef structure that
141 
*                    contains the configuration information for the specified
142 
*                    I2C peripheral.
143 
* Output         : None
144 
* Return         : None
145 
******************************************************************************/
146 
void I2C_Init(I2C_TypeDef* I2Cx, I2C_InitTypeDef* I2C_InitStruct)
147 
{
148 
  u16 tmpreg = 0, freqrange = 0;
149 
  u16 result = 0x04;
150 
  u32 pclk1clock = 12000000;
151 
  RCC_ClocksTypeDef  RCC_Clocks;
152 
 
153 
  /* Check the parameters */
154 
  assert(IS_I2C_MODE(I2C_InitStruct->I2C_Mode));
155 
  assert(IS_I2C_DUTY_CYCLE(I2C_InitStruct->I2C_DutyCycle));
156 
  assert(IS_I2C_OWN_ADDRESS1(I2C_InitStruct->I2C_OwnAddress1));
157 
  assert(IS_I2C_ACK_STATE(I2C_InitStruct->I2C_Ack));
158 
  assert(IS_I2C_ACKNOWLEDGE_ADDRESS(I2C_InitStruct->I2C_AcknowledgedAddress));
159 
  assert(IS_I2C_CLOCK_SPEED(I2C_InitStruct->I2C_ClockSpeed));
160 
 
161 
/*---------------------------- I2Cx CR2 Configuration ------------------------*/
162 
  /* Get the I2Cx CR2 value */
163 
  tmpreg = I2Cx->CR2;
164 
  /* Clear frequency FREQ[5:0] bits */
165 
  tmpreg &= CR2_FREQ_Reset;
166 
  /* Get PCLK1Clock frequency value */
167 
  RCC_GetClocksFreq(&RCC_Clocks);
168 
  pclk1clock = RCC_Clocks.PCLK1_Frequency;
169 
  /* Set frequency bits depending on PCLK1Clock value */
170 
  freqrange = (u16)(pclk1clock / 1000000);
171 
  tmpreg |= freqrange;
172 
  /* Write to I2Cx CR2 */
173 
  I2Cx->CR2 = tmpreg;
174 
 
175 
/*---------------------------- I2Cx CCR Configuration ------------------------*/
176 
  /* Disable I2Cx to configure TRISE */
177 
  I2C_Cmd(I2Cx, DISABLE);
178 
 
179 
  /* Reset tmpreg value */
180 
  /* Clear F/S, DUTY and CCR[11:0] bits */
181 
  tmpreg = 0;
182 
 
183 
  /* Configure speed in standard mode */
184 
  if (I2C_InitStruct->I2C_ClockSpeed <= 100000)
185 
  {
186 
    /* Standard mode speed calculate */
187 
    result = (u16)(pclk1clock / (I2C_InitStruct->I2C_ClockSpeed << 1));
188 
    /* Test if CCR value is under 0x4*/
189 
    if (result < 0x04)
190 
    {
191 
      /* Set minimum allowed value */
192 
      result = 0x04;
193 
    }
194 
    /* Set speed value for standard mode */
195 
    tmpreg |= result;
196 
    /* Set Maximum Rise Time: ((1000/(1000000000/pclk1clock))+1 */
197 
    I2Cx->TRISE = freqrange + 1;
198 
  }
199 
  /* Configure speed in fast mode */
200 
  else /*(I2C_InitStruct->I2C_ClockSpeed <= 400000)*/
201 
  {
202 
    if (I2C_InitStruct->I2C_DutyCycle == I2C_DutyCycle_2)
203 
    {
204 
      /* Fast mode speed calculate: Tlow/Thigh = 2 */
205 
      result = (u16)(pclk1clock / (I2C_InitStruct->I2C_ClockSpeed * 3));
206 
    }
207 
    else /*I2C_InitStruct->I2C_DutyCycle == I2C_DutyCycle_16_9*/
208 
    {
209 
      /* Fast mode speed calculate: Tlow/Thigh = 16/9 */
210 
      result = (u16)(pclk1clock / (I2C_InitStruct->I2C_ClockSpeed * 25));
211 
      /* Set DUTY bit */
212 
      result |= I2C_DutyCycle_16_9;
213 
    }
214 
    /* Test if CCR value is under 0x1*/
215 
    if ((result & CCR_CCR_Set) == 0)
216 
    {
217 
      /* Set minimum allowed value */
218 
      result |= (u16)0x0001;
219 
    }
220 
    /* Set speed value and set F/S bit for fast mode */
221 
    tmpreg |= result | CCR_FS_Set;
222 
    /* Set Maximum Rise Time: ((300/(1000000000/pclk1clock))+1 */
223 
    I2Cx->TRISE = (u16)(((freqrange * 300) / 1000) + 1);
224 
  }
225 
  /* Write to I2Cx CCR */
226 
  I2Cx->CCR = tmpreg;
227 
 
228 
  /* Enable I2Cx */
229 
  I2C_Cmd(I2Cx, ENABLE);
230 
 
231 
/*---------------------------- I2Cx CR1 Configuration ------------------------*/
232 
  /* Get the I2Cx CR1 value */
233 
  tmpreg = I2Cx->CR1;
234 
  /* Clear ACK, SMBTYPE and  SMBUS bits */
235 
  tmpreg &= CR1_CLEAR_Mask;
236 
  /* Configure I2Cx: mode and acknowledgement */
237 
  /* Set SMBTYPE and SMBUS bits according to I2C_Mode value */
238 
  /* Set ACK bit according to I2C_Ack value */
239 
  tmpreg |= (u16)((u32)I2C_InitStruct->I2C_Mode | I2C_InitStruct->I2C_Ack);
240 
  /* Write to I2Cx CR1 */
241 
  I2Cx->CR1 = tmpreg;
242 
 
243 
/*---------------------------- I2Cx OAR1 Configuration -----------------------*/
244 
  /* Set I2Cx Own Address1 and acknowledged address */
245 
  I2Cx->OAR1 = (I2C_InitStruct->I2C_AcknowledgedAddress | I2C_InitStruct->I2C_OwnAddress1);
246 
}
247 
 
248 
/*******************************************************************************
249 
* Function Name  : I2C_StructInit
250 
* Description    : Fills each I2C_InitStruct member with its default value.
251 
* Input          : - I2C_InitStruct: pointer to a I2C_InitTypeDef structure
252 
*                    which will be initialized.
253 
* Output         : None
254 
* Return         : None
255 
*******************************************************************************/
256 
void I2C_StructInit(I2C_InitTypeDef* I2C_InitStruct)
257 
{
258 
/*---------------- Reset I2C init structure parameters values ----------------*/
259 
  /* Initialize the I2C_Mode member */
260 
  I2C_InitStruct->I2C_Mode = I2C_Mode_I2C;
261 
 
262 
  /* Initialize the I2C_DutyCycle member */
263 
  I2C_InitStruct->I2C_DutyCycle = I2C_DutyCycle_2;
264 
 
265 
  /* Initialize the I2C_OwnAddress1 member */
266 
  I2C_InitStruct->I2C_OwnAddress1 = 0;
267 
 
268 
  /* Initialize the I2C_Ack member */
269 
  I2C_InitStruct->I2C_Ack = I2C_Ack_Disable;
270 
 
271 
  /* Initialize the I2C_AcknowledgedAddress member */
272 
  I2C_InitStruct->I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
273 
 
274 
  /* initialize the I2C_ClockSpeed member */
275 
  I2C_InitStruct->I2C_ClockSpeed = 5000;
276 
}
277 
 
278 
/*******************************************************************************
279 
* Function Name  : I2C_Cmd
280 
* Description    : Enables or disables the specified I2C peripheral.
281 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
282 
*                  - NewState: new state of the I2Cx peripheral. This parameter
283 
*                    can be: ENABLE or DISABLE.
284 
* Output         : None
285 
* Return         : None
286 
*******************************************************************************/
287 
void I2C_Cmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
288 
{
289 
  /* Check the parameters */
290 
  assert(IS_FUNCTIONAL_STATE(NewState));
291 
 
292 
  if (NewState != DISABLE)
293 
  {
294 
    /* Enable the selected I2C peripheral */
295 
    I2Cx->CR1 |= CR1_PE_Set;
296 
  }
297 
  else
298 
  {
299 
    /* Disable the selected I2C peripheral */
300 
    I2Cx->CR1 &= CR1_PE_Reset;
301 
  }
302 
}
303 
 
304 
/*******************************************************************************
305 
* Function Name  : I2C_DMACmd
306 
* Description    : Enables or disables the specified I2C DMA requests.
307 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
308 
*                  - NewState: new state of the I2C DMA transfer.
309 
*                    This parameter can be: ENABLE or DISABLE.
310 
* Output         : None
311 
* Return         : None
312 
*******************************************************************************/
313 
void I2C_DMACmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
314 
{
315 
  /* Check the parameters */
316 
  assert(IS_FUNCTIONAL_STATE(NewState));
317 
 
318 
  if (NewState != DISABLE)
319 
  {
320 
    /* Enable the selected I2C DMA requests */
321 
    I2Cx->CR2 |= CR2_DMAEN_Set;
322 
  }
323 
  else
324 
  {
325 
    /* Disable the selected I2C DMA requests */
326 
    I2Cx->CR2 &= CR2_DMAEN_Reset;
327 
  }
328 
}
329 
 
330 
/*******************************************************************************
331 
* Function Name  : I2C_DMALastTransferCmd
332 
* Description    : Specifies that the next DMA transfer is the last one.
333 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
334 
*                  - NewState: new state of the I2C DMA last transfer.
335 
*                    This parameter can be: ENABLE or DISABLE.
336 
* Output         : None
337 
* Return         : None
338 
*******************************************************************************/
339 
void I2C_DMALastTransferCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
340 
{
341 
  /* Check the parameters */
342 
  assert(IS_FUNCTIONAL_STATE(NewState));
343 
 
344 
  if (NewState != DISABLE)
345 
  {
346 
    /* Next DMA end of transfer is the last transfer */
347 
    I2Cx->CR2 |= CR2_LAST_Set;
348 
  }
349 
  else
350 
  {
351 
    /* Next DMA end of transfer is not the last transfer */
352 
    I2Cx->CR2 &= CR2_LAST_Reset;
353 
  }
354 
}
355 
 
356 
/*******************************************************************************
357 
* Function Name  : I2C_GenerateSTART
358 
* Description    : Generates I2Cx communication START condition.
359 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
360 
*                  - NewState: new state of the I2C START condition generation.
361 
*                    This parameter can be: ENABLE or DISABLE.
362 
* Output         : None
363 
* Return         : None.
364 
*******************************************************************************/
365 
void I2C_GenerateSTART(I2C_TypeDef* I2Cx, FunctionalState NewState)
366 
{
367 
  /* Check the parameters */
368 
  assert(IS_FUNCTIONAL_STATE(NewState));
369 
 
370 
  if (NewState != DISABLE)
371 
  {
372 
    /* Generate a START condition */
373 
    I2Cx->CR1 |= CR1_START_Set;
374 
  }
375 
  else
376 
  {
377 
    /* Disable the START condition generation */
378 
    I2Cx->CR1 &= CR1_START_Reset;
379 
  }
380 
}
381 
 
382 
/*******************************************************************************
383 
* Function Name  : I2C_GenerateSTOP
384 
* Description    : Generates I2Cx communication STOP condition.
385 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
386 
*                  - NewState: new state of the I2C STOP condition generation.
387 
*                    This parameter can be: ENABLE or DISABLE.
388 
* Output         : None
389 
* Return         : None.
390 
*******************************************************************************/
391 
void I2C_GenerateSTOP(I2C_TypeDef* I2Cx, FunctionalState NewState)
392 
{
393 
  /* Check the parameters */
394 
  assert(IS_FUNCTIONAL_STATE(NewState));
395 
 
396 
  if (NewState != DISABLE)
397 
  {
398 
    /* Generate a STOP condition */
399 
    I2Cx->CR1 |= CR1_STOP_Set;
400 
  }
401 
  else
402 
  {
403 
    /* Disable the STOP condition generation */
404 
    I2Cx->CR1 &= CR1_STOP_Reset;
405 
  }
406 
}
407 
 
408 
/*******************************************************************************
409 
* Function Name  : I2C_AcknowledgeConfig
410 
* Description    : Enables or disables the specified I2C acknowledge feature.
411 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
412 
*                  - NewState: new state of the I2C Acknowledgement.
413 
*                    This parameter can be: ENABLE or DISABLE.
414 
* Output         : None
415 
* Return         : None.
416 
*******************************************************************************/
417 
void I2C_AcknowledgeConfig(I2C_TypeDef* I2Cx, FunctionalState NewState)
418 
{
419 
  /* Check the parameters */
420 
  assert(IS_FUNCTIONAL_STATE(NewState));
421 
 
422 
  if (NewState != DISABLE)
423 
  {
424 
    /* Enable the acknowledgement */
425 
    I2Cx->CR1 |= CR1_ACK_Set;
426 
  }
427 
  else
428 
  {
429 
    /* Disable the acknowledgement */
430 
    I2Cx->CR1 &= CR1_ACK_Reset;
431 
  }
432 
}
433 
 
434 
/*******************************************************************************
435 
* Function Name  : I2C_OwnAddress2Config
436 
* Description    : Configures the specified I2C own address2.
437 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
438 
*                  - Address: specifies the 7bit I2C own address2.
439 
* Output         : None
440 
* Return         : None.
441 
*******************************************************************************/
442 
void I2C_OwnAddress2Config(I2C_TypeDef* I2Cx, u8 Address)
443 
{
444 
  u16 tmpreg = 0;
445 
 
446 
  /* Get the old register value */
447 
  tmpreg = I2Cx->OAR2;
448 
  /* Reset I2Cx Own address2 bit [7:1] */
449 
  tmpreg &= OAR2_ADD2_Reset;
450 
  /* Set I2Cx Own address2 */
451 
  tmpreg |= (u16)(Address & (u16)0x00FE);
452 
  /* Store the new register value */
453 
  I2Cx->OAR2 = tmpreg;
454 
}
455 
 
456 
/*******************************************************************************
457 
* Function Name  : I2C_DualAddressCmd
458 
* Description    : Enables or disables the specified I2C dual addressing mode.
459 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
460 
*                  - NewState: new state of the I2C dual addressing mode.
461 
*                    This parameter can be: ENABLE or DISABLE.
462 
* Output         : None
463 
* Return         : None
464 
*******************************************************************************/
465 
void I2C_DualAddressCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
466 
{
467 
  /* Check the parameters */
468 
  assert(IS_FUNCTIONAL_STATE(NewState));
469 
 
470 
  if (NewState != DISABLE)
471 
  {
472 
    /* Enable dual addressing mode */
473 
    I2Cx->OAR2 |= OAR2_ENDUAL_Set;
474 
  }
475 
  else
476 
  {
477 
    /* Disable dual addressing mode */
478 
    I2Cx->OAR2 &= OAR2_ENDUAL_Reset;
479 
  }
480 
}
481 
 
482 
/*******************************************************************************
483 
* Function Name  : I2C_GeneralCallCmd
484 
* Description    : Enables or disables the specified I2C general call feature.
485 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
486 
*                  - NewState: new state of the I2C General call.
487 
*                    This parameter can be: ENABLE or DISABLE.
488 
* Output         : None
489 
* Return         : None
490 
*******************************************************************************/
491 
void I2C_GeneralCallCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
492 
{
493 
  /* Check the parameters */
494 
  assert(IS_FUNCTIONAL_STATE(NewState));
495 
 
496 
  if (NewState != DISABLE)
497 
  {
498 
    /* Enable generall call */
499 
    I2Cx->CR1 |= CR1_ENGC_Set;
500 
  }
501 
  else
502 
  {
503 
    /* Disable generall call */
504 
    I2Cx->CR1 &= CR1_ENGC_Reset;
505 
  }
506 
}
507 
 
508 
/*******************************************************************************
509 
* Function Name  : I2C_ITConfig
510 
* Description    : Enables or disables the specified I2C interrupts.
511 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
512 
*                  - I2C_IT: specifies the I2C interrupts sources to be enabled
513 
*                    or disabled.
514 
*                    This parameter can be any combination of the following values:
515 
*                       - I2C_IT_BUF: Buffer interrupt mask
516 
*                       - I2C_IT_EVT: Event interrupt mask
517 
*                       - I2C_IT_ERR: Error interrupt mask
518 
*                  - NewState: new state of the specified I2C interrupts.
519 
*                    This parameter can be: ENABLE or DISABLE.
520 
* Output         : None
521 
* Return         : None
522 
*******************************************************************************/
523 
void I2C_ITConfig(I2C_TypeDef* I2Cx, u16 I2C_IT, FunctionalState NewState)
524 
{
525 
  /* Check the parameters */
526 
  assert(IS_FUNCTIONAL_STATE(NewState));
527 
  assert(IS_I2C_CONFIG_IT(I2C_IT));
528 
 
529 
  if (NewState != DISABLE)
530 
  {
531 
    /* Enable the selected I2C interrupts */
532 
    I2Cx->CR2 |= I2C_IT;
533 
  }
534 
  else
535 
  {
536 
    /* Disable the selected I2C interrupts */
537 
    I2Cx->CR2 &= (u16)~I2C_IT;
538 
  }
539 
}
540 
 
541 
/*******************************************************************************
542 
* Function Name  : I2C_SendData
543 
* Description    : Sends a data byte through the I2Cx peripheral.
544 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
545 
*                  - Data: Byte to be transmitted..
546 
* Output         : None
547 
* Return         : None
548 
*******************************************************************************/
549 
void I2C_SendData(I2C_TypeDef* I2Cx, u8 Data)
550 
{
551 
  /* Write in the DR register the data to be sent */
552 
  I2Cx->DR = Data;
553 
}
554 
 
555 
/*******************************************************************************
556 
* Function Name  : I2C_ReceiveData
557 
* Description    : Returns the most recent received data by the I2Cx peripheral.
558 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
559 
* Output         : None
560 
* Return         : The value of the received data.
561 
*******************************************************************************/
562 
u8 I2C_ReceiveData(I2C_TypeDef* I2Cx)
563 
{
564 
  /* Return the data in the DR register */
565 
  return (u8)I2Cx->DR;
566 
}
567 
 
568 
/*******************************************************************************
569 
* Function Name  : I2C_Send7bitAddress
570 
* Description    : Transmits the address byte to select the slave device.
571 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
572 
*                  - Address: specifies the slave address which will be transmitted
573 
*                  - Direction: specifies whether the I2C device will be a
574 
*                    Transmitter or a Receiver.
575 
*                    This parameter can be one of the following values
576 
*                       - I2C_Direction_Transmitter: Transmitter mode
577 
*                       - I2C_Direction_Receiver: Receiver mode
578 
* Output         : None
579 
* Return         : None.
580 
*******************************************************************************/
581 
void I2C_Send7bitAddress(I2C_TypeDef* I2Cx, u8 Address, u8 I2C_Direction)
582 
{
583 
  /* Check the parameters */
584 
  assert(IS_I2C_DIRECTION(I2C_Direction));
585 
 
586 
  /* Test on the direction to set/reset the read/write bit */
587 
  if (I2C_Direction != I2C_Direction_Transmitter)
588 
  {
589 
    /* Set the address ADD0 bit0 for read */
590 
    Address |= OAR1_ADD0_Set;
591 
  }
592 
  else
593 
  {
594 
    /* Reset the address bit0 for write */
595 
    Address &= OAR1_ADD0_Reset;
596 
  }
597 
  /* Send the address */
598 
  I2Cx->DR = Address;
599 
}
600 
 
601 
/*******************************************************************************
602 
* Function Name  : I2C_ReadRegister
603 
* Description    : Reads the specified I2C register and returns its value.
604 
* Input1         : - I2C_Register: specifies the register to read.
605 
*                    This parameter can be one of the following values:
606 
*                       - I2C_Register_CR1:  CR1 register.
607 
*                       - I2C_Register_CR2:   CR2 register.
608 
*                       - I2C_Register_OAR1:  OAR1 register.
609 
*                       - I2C_Register_OAR2:  OAR2 register.
610 
*                       - I2C_Register_DR:    DR register.
611 
*                       - I2C_Register_SR1:   SR1 register.
612 
*                       - I2C_Register_SR2:   SR2 register.
613 
*                       - I2C_Register_CCR:   CCR register.
614 
*                       - I2C_Register_TRISE: TRISE register.
615 
* Output         : None
616 
* Return         : The value of the read register.
617 
*******************************************************************************/
618 
u16 I2C_ReadRegister(I2C_TypeDef* I2Cx, u8 I2C_Register)
619 
{
620 
  /* Check the parameters */
621 
  assert(IS_I2C_REGISTER(I2C_Register));
622 
 
623 
  /* Return the selected register value */
624 
  return (*(u16 *)(*((u32 *)&I2Cx) + I2C_Register));
625 
}
626 
 
627 
/*******************************************************************************
628 
* Function Name  : I2C_SoftwareResetCmd
629 
* Description    : Enables or disables the specified I2C software reset.
630 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
631 
*                  - NewState: new state of the I2C software reset.
632 
*                    This parameter can be: ENABLE or DISABLE.
633 
* Output         : None
634 
* Return         : None
635 
*******************************************************************************/
636 
void I2C_SoftwareResetCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
637 
{
638 
  /* Check the parameters */
639 
  assert(IS_FUNCTIONAL_STATE(NewState));
640 
 
641 
  if (NewState != DISABLE)
642 
  {
643 
    /* Peripheral under reset */
644 
    I2Cx->CR1 |= CR1_SWRST_Set;
645 
  }
646 
  else
647 
  {
648 
    /* Peripheral not under reset */
649 
    I2Cx->CR1 &= CR1_SWRST_Reset;
650 
  }
651 
}
652 
 
653 
/*******************************************************************************
654 
* Function Name  : I2C_SMBusAlertConfig
655 
* Description    : Drives the SMBusAlert pin high or low for the specified I2C.
656 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
657 
*                  - I2C_SMBusAlert: specifies SMBAlert pin level.
658 
*                    This parameter can be one of the following values:
659 
*                       - I2C_SMBusAlert_Low: SMBAlert pin driven low
660 
*                       - I2C_SMBusAlert_High: SMBAlert pin driven high
661 
* Output         : None
662 
* Return         : None
663 
*******************************************************************************/
664 
void I2C_SMBusAlertConfig(I2C_TypeDef* I2Cx, u16 I2C_SMBusAlert)
665 
{
666 
  /* Check the parameters */
667 
  assert(IS_I2C_SMBUS_ALERT(I2C_SMBusAlert));
668 
 
669 
  if (I2C_SMBusAlert == I2C_SMBusAlert_Low)
670 
  {
671 
    /* Drive the SMBusAlert pin Low */
672 
    I2Cx->CR1 |= I2C_SMBusAlert_Low;
673 
  }
674 
  else
675 
  {
676 
    /* Drive the SMBusAlert pin High  */
677 
    I2Cx->CR1 &= I2C_SMBusAlert_High;
678 
  }
679 
}
680 
 
681 
/*******************************************************************************
682 
* Function Name  : I2C_TransmitPEC
683 
* Description    : Enables the specified I2C PEC transfer.
684 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
685 
* Output         : None
686 
* Return         : None
687 
*******************************************************************************/
688 
void I2C_TransmitPEC(I2C_TypeDef* I2Cx)
689 
{
690 
  /* Enable the selected I2C PEC transmission */
691 
  I2Cx->CR1 |= CR1_PEC_Set;
692 
}
693 
 
694 
/*******************************************************************************
695 
* Function Name  : I2C_PECPositionConfig
696 
* Description    : Selects the specified I2C PEC position.
697 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
698 
*                  - I2C_PECPosition: specifies the PEC position.
699 
*                    This parameter can be one of the following values:
700 
*                       - I2C_PECPosition_Next: PEC bit indicates that current
701 
*                         byte is PEC
702 
*                       - I2C_PECPosition_Current: PEC bit indicates that the
703 
*                         next byte is PEC
704 
* Output         : None
705 
* Return         : None
706 
*******************************************************************************/
707 
void I2C_PECPositionConfig(I2C_TypeDef* I2Cx, u16 I2C_PECPosition)
708 
{
709 
  /* Check the parameters */
710 
  assert(IS_I2C_PEC_POSITION(I2C_PECPosition));
711 
 
712 
  if (I2C_PECPosition == I2C_PECPosition_Next)
713 
  {
714 
    /* PEC indicates that the next byte in shift register is PEC */
715 
    I2Cx->CR1 |= I2C_PECPosition_Next;
716 
  }
717 
  else
718 
  {
719 
    /* PEC indicates that the current byte in shift register is PEC */
720 
    I2Cx->CR1 &= I2C_PECPosition_Current;
721 
  }
722 
}
723 
 
724 
/*******************************************************************************
725 
* Function Name  : I2C_CalculatePEC
726 
* Description    : Enables or disables the PEC value calculation of the
727 
*                  transfered bytes.
728 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
729 
*                  - NewState: new state of the I2Cx PEC value calculation.
730 
*                    This parameter can be: ENABLE or DISABLE.
731 
* Output         : None
732 
* Return         : None
733 
*******************************************************************************/
734 
void I2C_CalculatePEC(I2C_TypeDef* I2Cx, FunctionalState NewState)
735 
{
736 
  /* Check the parameters */
737 
  assert(IS_FUNCTIONAL_STATE(NewState));
738 
 
739 
  if (NewState != DISABLE)
740 
  {
741 
    /* Enable the selected I2C PEC calculation */
742 
    I2Cx->CR1 |= CR1_ENPEC_Set;
743 
  }
744 
  else
745 
  {
746 
    /* Disable the selected I2C PEC calculation */
747 
    I2Cx->CR1 &= CR1_ENPEC_Reset;
748 
  }
749 
}
750 
 
751 
/*******************************************************************************
752 
* Function Name  : I2C_GetPEC
753 
* Description    : Returns the PEC value for the specified I2C.
754 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
755 
* Output         : None
756 
* Return         : The PEC value.
757 
*******************************************************************************/
758 
u8 I2C_GetPEC(I2C_TypeDef* I2Cx)
759 
{
760 
  u8 pec;
761 
 
762 
  /* Get the PEC value */
763 
  pec = (I2Cx->SR2) >> 8;
764 
  /* Return the selected I2C PEC register value */
765 
  return pec;
766 
}
767 
 
768 
/*******************************************************************************
769 
* Function Name  : I2C_ARPCmd
770 
* Description    : Enables or disables the specified I2C ARP.
771 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
772 
*                  - NewState: new state of the I2Cx ARP.
773 
*                    This parameter can be: ENABLE or DISABLE.
774 
* Output         : None
775 
* Return         : None
776 
*******************************************************************************/
777 
void I2C_ARPCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
778 
{
779 
  /* Check the parameters */
780 
  assert(IS_FUNCTIONAL_STATE(NewState));
781 
 
782 
  if (NewState != DISABLE)
783 
  {
784 
    /* Enable the selected I2C ARP */
785 
    I2Cx->CR1 |= CR1_ENARP_Set;
786 
  }
787 
  else
788 
  {
789 
    /* Disable the selected I2C ARP */
790 
    I2Cx->CR1 &= CR1_ENARP_Reset;
791 
  }
792 
}
793 
 
794 
/*******************************************************************************
795 
* Function Name  : I2C_StretchClockCmd
796 
* Description    : Enables or disables the specified I2C Clock stretching.
797 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
798 
*                  - NewState: new state of the I2Cx Clock stretching.
799 
*                    This parameter can be: ENABLE or DISABLE.
800 
* Output         : None
801 
* Return         : None
802 
*******************************************************************************/
803 
void I2C_StretchClockCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
804 
{
805 
  /* Check the parameters */
806 
  assert(IS_FUNCTIONAL_STATE(NewState));
807 
 
808 
  if (NewState == DISABLE)
809 
  {
810 
    /* Enable the selected I2C Clock stretching */
811 
    I2Cx->CR1 |= CR1_NOSTRETCH_Set;
812 
  }
813 
  else
814 
  {
815 
    /* Disable the selected I2C Clock stretching */
816 
    I2Cx->CR1 &= CR1_NOSTRETCH_Reset;
817 
  }
818 
}
819 
 
820 
/*******************************************************************************
821 
* Function Name  : I2C_FastModeDutyCycleConfig
822 
* Description    : Selects the specified I2C fast mode duty cycle.
823 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
824 
*                  - I2C_DutyCycle: specifies the fast mode duty cycle.
825 
*                    This parameter can be one of the following values:
826 
*                       - I2C_DutyCycle_2: I2C fast mode Tlow/Thigh = 2
827 
*                       - I2C_DutyCycle_16_9: I2C fast mode Tlow/Thigh = 16/9
828 
* Output         : None
829 
* Return         : None
830 
*******************************************************************************/
831 
void I2C_FastModeDutyCycleConfig(I2C_TypeDef* I2Cx, u16 I2C_DutyCycle)
832 
{
833 
  /* Check the parameters */
834 
  assert(IS_I2C_DUTY_CYCLE(I2C_DutyCycle));
835 
 
836 
  if (I2C_DutyCycle != I2C_DutyCycle_16_9)
837 
  {
838 
    /* I2C fast mode Tlow/Thigh=2 */
839 
    I2Cx->CCR &= I2C_DutyCycle_2;
840 
  }
841 
  else
842 
  {
843 
    /* I2C fast mode Tlow/Thigh=16/9 */
844 
    I2Cx->CCR |= I2C_DutyCycle_16_9;
845 
  }
846 
}
847 
 
848 
/*******************************************************************************
849 
* Function Name  : I2C_GetLastEvent
850 
* Description    : Returns the Last I2C Event.
851 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
852 
* Output         : None
853 
* Return         : The last event
854 
*******************************************************************************/
855 
u32 I2C_GetLastEvent(I2C_TypeDef* I2Cx)
856 
{
857 
  u32 LastEvent = 0;
858 
  u32 Flag1 = 0, Flag2 = 0;
859 
 
860 
  Flag1 = I2Cx->SR1;
861 
  Flag2 = I2Cx->SR2;
862 
  Flag2 = Flag2 << 16;
863 
 
864 
  /* Get the last event value from I2C status register */
865 
  LastEvent = (Flag1 | Flag2) & I2C_FLAG_Mask;
866 
 
867 
  /* Return status */
868 
  return LastEvent;
869 
}
870 
 
871 
/*******************************************************************************
872 
* Function Name  : I2C_CheckEvent
873 
* Description    : Checks whether the Last I2C Event is equal to the one passed
874 
*                  as parameter.
875 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
876 
*                  - I2C_EVENT: specifies the event to be checked.
877 
*                    This parameter can be one of the following values:
878 
*                       - I2C_EVENT_SLAVE_ADDRESS_MATCHED   : EV1
879 
*                       - I2C_EVENT_SLAVE_BYTE_RECEIVED     : EV2
880 
*                       - I2C_EVENT_SLAVE_BYTE_TRANSMITTED  : EV3
881 
*                       - I2C_EVENT_SLAVE_ACK_FAILURE       : EV3-1
882 
*                       - I2C_EVENT_MASTER_MODE_SELECT      : EV5
883 
*                       - I2C_EVENT_MASTER_MODE_SELECTED    : EV6
884 
*                       - I2C_EVENT_MASTER_BYTE_RECEIVED    : EV7
885 
*                       - I2C_EVENT_MASTER_BYTE_TRANSMITTED : EV8
886 
*                       - I2C_EVENT_MASTER_MODE_ADDRESS10   : EV9
887 
*                       - I2C_EVENT_SLAVE_STOP_DETECTED     : EV4
888 
* Output         : None
889 
* Return         : An ErrorStatus enumuration value:
890 
*                       - SUCCESS: Last event is equal to the I2C_Event
891 
*                       - ERROR: Last event is different from the I2C_Event
892 
*******************************************************************************/
893 
ErrorStatus I2C_CheckEvent(I2C_TypeDef* I2Cx, u32 I2C_EVENT)
894 
{
895 
  u32 LastEvent = 0;
896 
  u32 Flag1 = 0, Flag2 = 0;
897 
  ErrorStatus status = ERROR;
898 
 
899 
  /* Check the parameters */
900 
  assert(IS_I2C_EVENT(I2C_EVENT));
901 
 
902 
  Flag1 = I2Cx->SR1;
903 
  Flag2 = I2Cx->SR2;
904 
  Flag2 = Flag2 << 16;
905 
 
906 
  /* Get the last event value from I2C status register */
907 
  LastEvent = (Flag1 | Flag2) & I2C_FLAG_Mask;
908 
 
909 
  /* Check whether the last event is equal to I2C_EVENT */
910 
  if (LastEvent == I2C_EVENT )
911 
  {
912 
    /* SUCCESS: last event is equal to I2C_EVENT */
913 
    status = SUCCESS;
914 
  }
915 
  else
916 
  {
917 
    /* ERROR: last event is different from I2C_EVENT */
918 
    status = ERROR;
919 
  }
920 
 
921 
  /* Return status */
922 
  return status;
923 
}
924 
 
925 
/*******************************************************************************
926 
* Function Name  : I2C_GetFlagStatus
927 
* Description    : Checks whether the specified I2C flag is set or not.
928 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
929 
*                  - I2C_FLAG: specifies the flag to check.
930 
*                    This parameter can be one of the following values:
931 
*                       - I2C_FLAG_DUALF: Dual flag (Slave mode)
932 
*                       - I2C_FLAG_SMBHOST: SMBus host header (Slave mode)
933 
*                       - I2C_FLAG_SMBDEFAULT: SMBus default header (Slave mode)
934 
*                       - I2C_FLAG_GENCALL: General call header flag (Slave mode)
935 
*                       - I2C_FLAG_TRA: Transmitter/Receiver flag
936 
*                       - I2C_FLAG_BUSY: Bus busy flag
937 
*                       - I2C_FLAG_MSL: Master/Slave flag
938 
*                       - I2C_FLAG_SMBALERT: SMBus Alert flag
939 
*                       - I2C_FLAG_TIMEOUT: Timeout or Tlow error flag
940 
*                       - I2C_FLAG_PECERR: PEC error in reception flag
941 
*                       - I2C_FLAG_OVR: Overrun/Underrun flag (Slave mode)
942 
*                       - I2C_FLAG_AF: Acknowledge failure flag
943 
*                       - I2C_FLAG_ARLO: Arbitration lost flag (Master mode)
944 
*                       - I2C_FLAG_BERR: Bus error flag
945 
*                       - I2C_FLAG_TXE: Data register empty flag (Transmitter)
946 
*                       - I2C_FLAG_RXNE: Data register not empty (Receiver) flag
947 
*                       - I2C_FLAG_STOPF: Stop detection flag (Slave mode)
948 
*                       - I2C_FLAG_ADD10: 10-bit header sent flag (Master mode)
949 
*                       - I2C_FLAG_BTF: Byte transfer finished flag
950 
*                       - I2C_FLAG_ADDR: Address sent flag (Master mode) “ADSL”
951 
*                                        Address matched flag (Slave mode)”ENDAD”
952 
*                       - I2C_FLAG_SB: Start bit flag (Master mode)
953 
* Output         : None
954 
* Return         : The new state of I2C_FLAG (SET or RESET).
955 
*******************************************************************************/
956 
FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, u32 I2C_FLAG)
957 
{
958 
  FlagStatus bitstatus = RESET;
959 
  u32 i2cstatus = 0;
960 
  u32 Flag1 = 0, Flag2 = 0;
961 
 
962 
  /* Check the parameters */
963 
  assert(IS_I2C_GET_FLAG(I2C_FLAG));
964 
 
965 
  /* Read the I2Cx status register */
966 
  Flag1 = I2Cx->SR1;
967 
  Flag2 = I2Cx->SR2;
968 
  Flag2 = (Flag2 & I2C_FLAG_Mask) << 16;
969 
 
970 
  /* Get the I2C status value */
971 
  i2cstatus = Flag1 | Flag2;
972 
 
973 
  /* Get bit[27:0] of the flag */
974 
  I2C_FLAG &= I2C_FLAG_Mask;
975 
 
976 
  /* Check the status of the specified I2C flag */
977 
  if ((i2cstatus & I2C_FLAG) != (u32)RESET)
978 
  {
979 
    /* I2C_FLAG is set */
980 
    bitstatus = SET;
981 
  }
982 
  else
983 
  {
984 
    /* I2C_FLAG is reset */
985 
    bitstatus = RESET;
986 
  }
987 
  /* Return the I2C_FLAG status */
988 
  return  bitstatus;
989 
}
990 
 
991 
/*******************************************************************************
992 
* Function Name  : I2C_ClearFlag
993 
* Description    : Clears the I2Cx's pending flags.
994 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
995 
*                  - I2C_FLAG: specifies the flag to clear.
996 
*                    This parameter can be one of the following values:
997 
*                       - I2C_FLAG_SMBALERT: SMBus Alert flag
998 
*                       - I2C_FLAG_TIMEOUT: Timeout or Tlow error flag
999 
*                       - I2C_FLAG_PECERR: PEC error in reception flag
1000 
*                       - I2C_FLAG_OVR: Overrun/Underrun flag (Slave mode)
1001 
*                       - I2C_FLAG_AF: Acknowledge failure flag
1002 
*                       - I2C_FLAG_ARLO: Arbitration lost flag (Master mode)
1003 
*                       - I2C_FLAG_BERR: Bus error flag
1004 
*                       - I2C_FLAG_STOPF: Stop detection flag (Slave mode)
1005 
*                       - I2C_FLAG_ADD10: 10-bit header sent flag (Master mode)
1006 
*                       - I2C_FLAG_BTF: Byte transfer finished flag
1007 
*                       - I2C_FLAG_ADDR: Address sent flag (Master mode) “ADSL”
1008 
*                                        Address matched flag (Slave mode)”ENDAD”
1009 
*                       - I2C_FLAG_SB: Start bit flag (Master mode)
1010 
* Output         : None
1011 
* Return         : None
1012 
*******************************************************************************/
1013 
void I2C_ClearFlag(I2C_TypeDef* I2Cx, u32 I2C_FLAG)
1014 
{
1015 
  u32 flagpos = 0;
1016 
  u8 flagindex = 0;
1017 
 
1018 
  /* Check the parameters */
1019 
  assert(IS_I2C_CLEAR_FLAG(I2C_FLAG));
1020 
 
1021 
  /* Get the I2C flag position */
1022 
  flagpos = I2C_FLAG & I2C_FLAG_Mask;
1023 
 
1024 
  /* Get the I2C flag index */
1025 
  flagindex = I2C_FLAG >> 28;
1026 
 
1027 
  /* Clear the flag by writing 0 */
1028 
  if (flagindex == 1)
1029 
  {
1030 
    /* Clear the selected I2C flag */
1031 
    I2Cx->SR1 &= ~flagpos;
1032 
  }
1033 
  /* Flags that need a read of the SR1 register to be cleared */
1034 
  else if (flagindex == 2)
1035 
  {
1036 
    /* Read the SR1 register */
1037 
    (void)I2Cx->SR1;
1038 
  }
1039 
  /* Flags that need a read of SR1 and a write on CR2 registers to be cleared */
1040 
  else if (flagindex == 6)
1041 
  {
1042 
    /* Read the SR1 register */
1043 
    (void)I2Cx->SR1;
1044 
 
1045 
    /* Write on the CR1 register */
1046 
    I2Cx->CR1 |= CR1_PE_Set;
1047 
  }
1048 
  /* Flags that need a read of SR1 and a write on CR2 registers to be cleared */
1049 
  else /*flagindex == 0xA*/
1050 
  {
1051 
    /* Read the SR1 register */
1052 
    (void)I2Cx->SR1;
1053 
 
1054 
    /* Read the SR2 register */
1055 
    (void)I2Cx->SR2;
1056 
  }
1057 
}
1058 
 
1059 
/*******************************************************************************
1060 
* Function Name  : I2C_GetITStatus
1061 
* Description    : Checks whether the specified I2C interrupt has occurred or not.
1062 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
1063 
*                  - I2C_IT: specifies the interrupt source to check.
1064 
*                    This parameter can be one of the following values:
1065 
*                       - I2C_IT_SMBALERT: SMBus Alert flag
1066 
*                       - I2C_IT_TIMEOUT: Timeout or Tlow error flag
1067 
*                       - I2C_IT_PECERR: PEC error in reception flag
1068 
*                       - I2C_IT_OVR: Overrun/Underrun flag (Slave mode)
1069 
*                       - I2C_IT_AF: Acknowledge failure flag
1070 
*                       - I2C_IT_ARLO: Arbitration lost flag (Master mode)
1071 
*                       - I2C_IT_BERR: Bus error flag
1072 
*                       - I2C_IT_TXE: Data register empty flag (Transmitter)
1073 
*                       - I2C_IT_RXNE: Data register not empty (Receiver) flag
1074 
*                       - I2C_IT_STOPF: Stop detection flag (Slave mode)
1075 
*                       - I2C_IT_ADD10: 10-bit header sent flag (Master mode)
1076 
*                       - I2C_IT_BTF: Byte transfer finished flag
1077 
*                       - I2C_IT_ADDR: Address sent flag (Master mode) “ADSL”
1078 
*                                        Address matched flag (Slave mode)”ENDAD”
1079 
*                       - I2C_IT_SB: Start bit flag (Master mode)
1080 
* Output         : None
1081 
* Return         : The new state of I2C_IT (SET or RESET).
1082 
*******************************************************************************/
1083 
ITStatus I2C_GetITStatus(I2C_TypeDef* I2Cx, u32 I2C_IT)
1084 
{
1085 
  ITStatus bitstatus = RESET;
1086 
  u32 i2cstatus = 0;
1087 
  u32 Flag1 = 0, Flag2 = 0;
1088 
 
1089 
  /* Check the parameters */
1090 
  assert(IS_I2C_GET_IT(I2C_IT));
1091 
 
1092 
  /* Read the I2Cx status register */
1093 
  Flag1 = I2Cx->SR1;
1094 
  Flag2 = I2Cx->SR2;
1095 
  Flag2 = (Flag2 & I2C_FLAG_Mask) << 16;
1096 
 
1097 
  /* Get the I2C status value */
1098 
  i2cstatus = Flag1 | Flag2;
1099 
 
1100 
  /* Get bit[27:0] of the flag */
1101 
  I2C_IT &= I2C_FLAG_Mask;
1102 
 
1103 
  /* Check the status of the specified I2C flag */
1104 
  if ((i2cstatus & I2C_IT) != (u32)RESET)
1105 
  {
1106 
    /* I2C_IT is set */
1107 
    bitstatus = SET;
1108 
  }
1109 
  else
1110 
  {
1111 
    /* I2C_IT is reset */
1112 
    bitstatus = RESET;
1113 
  }
1114 
  /* Return the I2C_IT status */
1115 
  return  bitstatus;
1116 
}
1117 
 
1118 
/*******************************************************************************
1119 
* Function Name  : I2C_ClearITPendingBit
1120 
* Description    : Clears the I2Cx’s interrupt pending bits.
1121 
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
1122 
*                  - I2C_IT: specifies the interrupt pending to clear.
1123 
*                    This parameter can be one of the following values:
1124 
*                       - I2C_IT_SMBALERT: SMBus Alert flag
1125 
*                       - I2C_IT_TIMEOUT: Timeout or Tlow error flag
1126 
*                       - I2C_IT_PECERR: PEC error in reception flag
1127 
*                       - I2C_IT_OVR: Overrun/Underrun flag (Slave mode)
1128 
*                       - I2C_IT_AF: Acknowledge failure flag
1129 
*                       - I2C_IT_ARLO: Arbitration lost flag (Master mode)
1130 
*                       - I2C_IT_BERR: Bus error flag
1131 
*                       - I2C_IT_STOPF: Stop detection flag (Slave mode)
1132 
*                       - I2C_IT_ADD10: 10-bit header sent flag (Master mode)
1133 
*                       - I2C_IT_BTF: Byte transfer finished flag
1134 
*                       - I2C_IT_ADDR: Address sent flag (Master mode) “ADSL”
1135 
*                                        Address matched flag (Slave mode)”ENDAD”
1136 
*                       - I2C_IT_SB: Start bit flag (Master mode)
1137 
* Output         : None
1138 
* Return         : None
1139 
*******************************************************************************/
1140 
void I2C_ClearITPendingBit(I2C_TypeDef* I2Cx, u32 I2C_IT)
1141 
{
1142 
  u32 flagpos = 0;
1143 
  u8 flagindex = 0;
1144 
 
1145 
  /* Check the parameters */
1146 
  assert(IS_I2C_CLEAR_IT(I2C_IT));
1147 
 
1148 
  /* Get the I2C flag position */
1149 
  flagpos = I2C_IT & I2C_FLAG_Mask;
1150 
 
1151 
  /* Get the I2C flag index */
1152 
  flagindex = I2C_IT >> 28;
1153 
 
1154 
  /* Clear the flag by writing 0 */
1155 
  if (flagindex == 1)
1156 
  {
1157 
    /* Clear the selected I2C flag */
1158 
    I2Cx->SR1 &= ~flagpos;
1159 
  }
1160 
  /* Flags that need a read of the SR1 register to be cleared */
1161 
  else if (flagindex == 2)
1162 
  {
1163 
    /* Read the SR1 register */
1164 
    (void)I2Cx->SR1;
1165 
  }
1166 
  /* Flags that need a read of SR1 and a write on CR2 registers to be cleared */
1167 
  else if (flagindex == 6)
1168 
  {
1169 
    /* Read the SR1 register */
1170 
    (void)I2Cx->SR1;
1171 
 
1172 
    /* Write on the CR1 register */
1173 
    I2Cx->CR1 |= CR1_PE_Set;
1174 
  }
1175 
  /* Flags that need a read of SR1 and a write on CR2 registers to be cleared */
1176 
  else /*flagindex == 0xA*/
1177 
  {
1178 
    /* Read the SR1 register */
1179 
    (void)I2Cx->SR1;
1180 
 
1181 
    /* Read the SR2 register */
1182 
    (void)I2Cx->SR2;
1183 
  }
1184 
}
1185 
 
1186 
/******************* (C) COPYRIGHT 2007 STMicroelectronics *****END OF FILE****/

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.