[STM32] Impossible de faire fonctionner l'I2C [Résolu]

[Lea92ch]

Salut à tous,

J’ai créé un PCB custom sur lequel un STM32 vient piloter deux drivers de LEDs (des PCA9622 de NXP : datasheet). Afin de tester l’I2C, mon programme envoie des data à une adresse bidon dans une boucle infinie.

Mon problème : Je n’ai aucun signal sur mes lignes SCL et SDA. Elles sont tout le temps à l’état bas.

Ce que j’ai testé :

• J’ai vérifié mes connections avec un multimètre, toutes les soudures semblent correctes
• J’ai retiré les pull up de l’I2C puis retesté, puis je les ai remplacées par des 10k. Rien n’a changé
• J’ai trouvé ce post sur un autre forum : post. Même si le STM32 n’est pas celui que j’utilise, la même errata sheet existe pour ma référence : Errata sheet. J’ai testé le workaround proposé par ST qui est implémentée en commentaire du post. J’ai dû le modifier en commentant les lignes GPIO_InitStructure.Alternate car GPIO_InitTypeDef n’a pas de membre Alternate. Je ne vois toujours pas de clock ni de data.
• J’ai dessoudé les solder jump des deux PCA pour voir si le problème venait d’eux. Les lignes I2C ne sont donc plus reliées à rien. Pourtant, je n’observe toujours rien sur SDA et SCL.

Avant de faire mon PCB custom, j’avais testé un PCA avec une Nucleo et ça fonctionnait bien donc je ne pense donc pas que le problème vienne d’une non-compatibilité entre le STM32 en 3.3V et le PCA9622 en 5V.
Je précise également que n’ayant pas d’alim de labo possédant 2 sorties, le 3.3V est pris d’une Nucleo (qui me sert aussi pour le ST-link) branchée sur l’ordinateur. Le 5V vient de l’alim de labo. Tous les grounds sont connectés entre eux.

Les parties de mon schéma concernées :
Pièce jointe 469022

Je suis un peu désespérée, je ne sais plus quoi tester. Merci à tous ceux qui prendront le temps de répondre.

Léa
-----

[gienas]

Bonjour Lea92ch et tout le groupe

... Les parties de mon schéma concernées : ...

La dite pièce jointe n’est pas présente.

[Lea92ch]

Bonjour,

Etrange pourtant je l'ai bien chargée. Je réessaie ici:

[jiherve]

bonjour
Dejà il manque les translateurs de niveaux entre I²C 3.3V et I²C 5V; Une paire de NMOS dit "TTL", schémas disponibles sur internet.
Mais ce n'est sans doute pas l'origine du problème.
JR

[A voir en vidéo sur Futura]

[gienas]

... Mon problème : Je n’ai aucun signal sur mes lignes SCL et SDA. Elles sont tout le temps à l’état bas ...

Je ne comprends rien à ton schéma.

Les bornes I2C sont des entrées sorties ”gérées" par le micro, chef d’orchestre.

Qui joue ce rôle ici? Ces lignes doivent être uniques.

[Lea92ch]

Merci pour la réponse jiherve Effectivement j'en intègrerai dans mon prochain PCB. Quelque chose de ce type:

[Lea92ch]

gienas,
Le stm32 est le micro qui est master de l'I2C. Il y a deux slaves qui sont les deux PCA9622.

[gienas]

... Le stm32 est le micro qui est master de l'I2C ...

As-tu vérifié que son programme gère bien le bus I2C alors que les esclaves sont débranchés?

[Lea92ch]

Oui, les deux esclaves ne sont plus reliés à l'I2C. Ils ne sont même plus alimentés en 5V. Les lignes SDA et SCL qui sortent de mon STM32 vont nulle part maintenant. Et pourtant je n'observe toujours rien sur ces lignes.

[gienas]

Oui, les deux esclaves ne sont plus reliés à l'I2C ... Et pourtant je n'observe toujours rien sur ces lignes.

Hum. J'aurais tendance à "accuser" le programme, qui, si des demandes sont faites, doit pulser le clock.

[antek]

Les niveaux SCL SDA sont bien à 1 au repos ?
Les I/O sont bien paramétrées en entrée ?
Si tu ne vois même pas le start je mettrais en cause le programme.

[jiherve]

bonsoir
si il n'y a pas de niveau "1" avec les pull up c'est effectivement sans doute du logiciel, mauvaise configuration du µC.
JR

[Lea92ch]

Bonsoir,

Merci pour vos réponses. Les lignes I2C sont bien à l'état haut quand je remets des pull-up (10k).

En ce qui concerne le programme, je l'ai remis en doute après vos commentaires et j'ai donc fait une version allégée :

1. J'ai configuré l'I2C avec CubeMX
2. J'ai ajouté dans le main ces quelques lignes:
   

   uint8_t buf[5] = {0, 1, 2, 3, 4};
   while(1){
     HAL_I2C_Master_Transmit(&hi2c1, 0x20, buf, 5*sizeof(uint8_t), 1000);
     HAL_Delay(100);
   }

Il ne se passe absolument rien sur les lignes SDA et SCL, elles semblent bloquées à l'état haut. HAL_I2C_Master_Transmit renvoie HAL_BUSY en permanence.

[gienas]

Bonjour à tous

… Il ne se passe absolument rien sur les lignes SDA et SCL, elles semblent bloquées à l'état haut …

Ce qui semble indiquer qu’elles ne sont pas "actives".

C’est le programme qui s’en charge, avec une initialisation dans le boot.

Je ne connais pas le STM32 mais la "philosophie" est la même pour tout le monde.

Il faut initialiser au démarrage.

Les routines de lecture/écriture font l’objet de bibliothèques dont il faut s’assurer qu’elles sont correctement utilisées et que ce sont bien celles qui sont compatibles.

[umfred]

coté codé, il n'y a pas une fonction type I2c_init à utiliser avant tout?
ou dans CubeMX, tu as bien modifier le paramètre I2CDisabled en I2C https://www.digikey.com/en/maker/pro...796.1667387640

[Bitrode]

Les niveaux SCL SDA sont bien à 1 au repos ?
Les I/O sont bien paramétrées en entrée ?
Si tu ne vois même pas le start je mettrais en cause le programme.

SCL doit être configuré en sortie et non pas en entrée, si tu parles bien du µC puisque c'est lui qui génère la clock.

[Bitrode]

A vérifier mais les STM32 sont généralement 5V tolérant sur ces I/O, perso j'enlèverai ce bricolage et je testerai déjà le code pour voir si tu obtiens des trames I2C, sans rien d'autres que les pull-up, sur SCL et SDA.

[antek]

SCL doit être configuré en sortie et non pas en entrée, si tu parles bien du µC puisque c'est lui qui génère la clock.

Le schéma habituel sur les pic16fxxx est de configurer les pin i2c en entrée, le module pouvant alors surveiller l'état des pin.
Je suppose (à tord ?) que le même principe est utilisé sur la plupart des µC.

[jiherve]

bonsoir,
c'est l'usage en cas de multimaitres mais s'il n'y a qu'un maitre : SCK sortie seulement active a "0" because clock streching ,SDA entrée.
Donc après reset , avant toute activité demandée si les 2 lignes dotées de pull up ne sont pas a '1' c'est qu'il y a un problème d'initialisation.
JR

[antek]

. . . SCK sortie seulement active a "0" because clock streching . . .

Rien compris . . .
L'esclave échantillonne SDA à partir du front montant de SCL, et le maître DOIT surveiller la ligne SCL (parce que l'esclave peut la mettre à zéro) quelle que soit la configuration du bus.

[jiherve]

Bonjour,

SCK sortie seulement active a "0"

<=> Open drain ou open collector pas une IO classique
sur Atmel le pilotage se fait par une combinaison PORTx,DDRx

because clock streching

<=> ou cablé implicite!
là on utilise PINx pour surveiller
Il n'est pas besoin de configurer SCK en entrée car sur la plupart des µC c'est la fonction par défaut des I/O on peut toujours relire une sortie
JR

[antek]

Oui . . .

Il n'est pas besoin de configurer SCK en entrée

Oui aussi, mais SCL doit bien être configuré en entrée, même si pas besoin de le configurer activement.

Ce sont des détails à résoudre au cas par cas avec la datasheet . . .

[jiherve]

re
en général sur un µC ce qu'il faut faire c'est associer une pin à une fonction sur Atmel on configure la pin en entrée et/ou sortie mais c'est l'activation de la fonction TWI qui associera la pin à la fonction SCK/SCL ,tant que l'ensemble n'est pas cohérent cela fait n'importe quoi.
Par ailleurs comme certaines pins peuvent avoir des associations multiples attention au conflits.
JR

[sandrecarpe]

Salut,

Peux-tu nous fournir le code entier concernant l'I2C et l'initialisation des IO ?

[Lea92ch]

Bonsoir à tous, merci pour toutes vos réponses, je m’excuse du délai de ma réponse, je n’ai pas eu le temps de m’y replonger depuis.

Pour simplifier encore plus le problème et être sûr que c’était un problème de code, j’ai testé avec une Nucleo-F103RB (la board d’évaluation de mon microcontrôleur). J’ai utilisé CubeMX qui m’a généré les I/O par défaut ainsi que du code d’initialisation. J’ai juste rajouté l’I2C en laissant sa configuration par défaut.

Ensuite, dans le code généré par CubeMX, j’ai juste rajouté trois lignes pour l’envoi des données en I2C.

Résultat : mes lignes I2C sont toujours à l’état haut. Il semblerait donc que mon problème vienne du code.

Quelques informations complémentaires :

• L’I2C n’est relié à rien à part mon analyseur logique. L’adresse de l’envoi est donc aléatoire.
• J’ai remarqué dans le schéma de la Nucleo qu’il n’y avait pas de pull up mais comme mes lignes I2C sont bloquées à l’état haut je ne pense pas que le problème vienne de là.
• J’ai essayé de mettre PB6 en GPIO output et de faire changer son état tous les 500ms. J’observe bien les changements sur mon analyseur logique donc je regarde bien au bon endroit.

Voici le projet complet : Nucleo-F103RB.zip

Voici le code du main (j'ai mis en gras ce que j'ai rajouté, le reste est généré par CubeMX):

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
 I2C_HandleTypeDef hi2c1;

UART_HandleTypeDef huart2;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_I2C1_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART2_UART_Init();
  MX_I2C1_Init();
  /* USER CODE BEGIN 2 */
  uint8_t buf[2];
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    HAL_I2C_Master_Transmit(&hi2c1, 0x20<<1, buf, 2, HAL_MAX_DELAY);
    HAL_Delay(500);
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI_DIV2;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL16;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief I2C1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_I2C1_Init(void)
{

  /* USER CODE BEGIN I2C1_Init 0 */

  /* USER CODE END I2C1_Init 0 */

  /* USER CODE BEGIN I2C1_Init 1 */

  /* USER CODE END I2C1_Init 1 */
  hi2c1.Instance = I2C1;
  hi2c1.Init.ClockSpeed = 100000;
  hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
  hi2c1.Init.OwnAddress1 = 0;
  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c1.Init.OwnAddress2 = 0;
  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN I2C1_Init 2 */

  /* USER CODE END I2C1_Init 2 */

}

/**
  * @brief USART2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART2_UART_Init(void)
{

  /* USER CODE BEGIN USART2_Init 0 */

  /* USER CODE END USART2_Init 0 */

  /* USER CODE BEGIN USART2_Init 1 */

  /* USER CODE END USART2_Init 1 */
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */

  /* USER CODE END USART2_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin : B1_Pin */
  GPIO_InitStruct.Pin = B1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(B1_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : LD2_Pin */
  GPIO_InitStruct.Pin = LD2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(LD2_GPIO_Port, &GPIO_InitStruct);

  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI15_10_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

Merci encore

Léa

[Unwanted Ads]

Il n'y aurait pas uun probleme suur la config des clocks?

Quand je regarde l schematics il y fait mention d'un quartz HSE 16Mhz qui est mis a 8 MHz dans cubemx et puis non utilise car selectionne HSI...

[Lea92ch]

Effectivement, j'utilise la clock interne dans un premier temps pour éviter une source d'erreur supplémentaire

[sandrecarpe]

Je ne vois pas la config des IO pour l'I2C ni l'activation de la clock I2C
On peut voir le contenu du fichier hal_msp ?
Tu as regardé en mode debug si l'écriture dans tes registres est bien effectuée ?

Au final je n'ai pas compris si ton setup contenait les pull up sur les lignes I2C. En tout cas, il en faut en moins une sur SDA et une sur SCL

[Unwanted Ads]

sinon est ce que tu pourrais debugger le CPU et regarder les valeurs des registers lies au I2c et au RCC

[Lea92ch]

On peut voir le contenu du fichier hal_msp

Contenu du fichier stm32f1xx_hal_msp.c:

/**
  * Initializes the Global MSP.
  */
void HAL_MspInit(void)
{
  /* USER CODE BEGIN MspInit 0 */

  /* USER CODE END MspInit 0 */

  __HAL_RCC_AFIO_CLK_ENABLE();
  __HAL_RCC_PWR_CLK_ENABLE();

  /* System interrupt init*/

  /** NOJTAG: JTAG-DP Disabled and SW-DP Enabled
  */
  __HAL_AFIO_REMAP_SWJ_NOJTAG();

  /* USER CODE BEGIN MspInit 1 */

  /* USER CODE END MspInit 1 */
}

/**
* @brief I2C MSP Initialization
* This function configures the hardware resources used in this example
* @param hi2c: I2C handle pointer
* @retval None
*/
void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(hi2c->Instance==I2C1)
  {
  /* USER CODE BEGIN I2C1_MspInit 0 */

  /* USER CODE END I2C1_MspInit 0 */

    __HAL_RCC_GPIOB_CLK_ENABLE();
    /**I2C1 GPIO Configuration
    PB6     ------> I2C1_SCL
    PB7     ------> I2C1_SDA
    */
    GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    /* Peripheral clock enable */
    __HAL_RCC_I2C1_CLK_ENABLE();
  /* USER CODE BEGIN I2C1_MspInit 1 */

  /* USER CODE END I2C1_MspInit 1 */
  }

}

/**
* @brief I2C MSP De-Initialization
* This function freeze the hardware resources used in this example
* @param hi2c: I2C handle pointer
* @retval None
*/
void HAL_I2C_MspDeInit(I2C_HandleTypeDef* hi2c)
{
  if(hi2c->Instance==I2C1)
  {
  /* USER CODE BEGIN I2C1_MspDeInit 0 */

  /* USER CODE END I2C1_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_I2C1_CLK_DISABLE();

    /**I2C1 GPIO Configuration
    PB6     ------> I2C1_SCL
    PB7     ------> I2C1_SDA
    */
    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_6);

    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_7);

  /* USER CODE BEGIN I2C1_MspDeInit 1 */

  /* USER CODE END I2C1_MspDeInit 1 */
  }

}

Tu as regardé en mode debug si l'écriture dans tes registres est bien effectuée

Oui les registres de l'I2C1 ne sont jamais modifiés. Il bloque trop tôt lors dans la fonction d'écriture, il arrive au timeout car le flag BUSY n'est jamais reset:

HAL_StatusTypeDef HAL_I2C_Master_Transmit(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout)
{
  /* Init tickstart for timeout management*/
  uint32_t tickstart = HAL_GetTick();

  if (hi2c->State == HAL_I2C_STATE_READY)
  {
    /* Wait until BUSY flag is reset */
    if (I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_BUSY, SET, I2C_TIMEOUT_BUSY_FLAG, tickstart) != HAL_OK)
    {
      return HAL_BUSY;
    }

   [...]
}

Au final je n'ai pas compris si ton setup contenait les pull up sur les lignes I2C. En tout cas, il en faut en moins une sur SDA et une sur SCL

Non, actuellement je ne suis plus sur ma board custom. Je suis une board d'évaluation pour écarter les erreurs dues à mon HW. Sur cette board d'évaluation il n'y a pas de pull up. Je vais en rajouter pour écarter ce problème aussi.

sinon est ce que tu pourrais debugger le CPU et regarder les valeurs des registers lies au I2c et au RCC

Au moment de l'essai d'envoi, les valeurs des registres de l'I2C sont comme cela:



Léa