{"id":5666,"date":"2020-03-23T14:20:33","date_gmt":"2020-03-23T21:20:33","guid":{"rendered":"https:\/\/visualgdb.com\/w\/?p=5666"},"modified":"2020-03-23T14:28:53","modified_gmt":"2020-03-23T21:28:53","slug":"using-the-i2c-interface-on-the-stm32-devices","status":"publish","type":"post","link":"https:\/\/visualgdb.com\/tutorials\/arm\/stm32\/i2c\/","title":{"rendered":"Using the I2C Interface on the STM32 Devices"},"content":{"rendered":"

This tutorial shows how to use the I2C interface on the STM32 devices. We will connect 2 STM32 boards using their I2C interface, will go over the I2C packet format, and will show how to use the STM32 HAL API to send and receive message using I2C. We will use a third STM32 board together with Analyzer2Go<\/a> to look into the I2C signals.<\/p>\n

Before you begin, install Visual Studio and VisualGDB.<\/p>\n

    \n
  1. We will begin with creating a basic project sending a simple message over I2C in the master<\/strong> mode. Start Visual Studio and open the VisualGDB Embedded Project Wizard:\"\"<\/a><\/li>\n
  2. Enter the name and location for your project and click “Create” to launch the VisualGDB-specific part of the wizard:\"\"<\/a><\/li>\n
  3. Proceed with the default settings (Create a new Embedded Binary using MSBuild) on the first page of the VisualGDB’s Wizard:\"\"<\/a><\/li>\n
  4. On the next page, select your device. In this example, we will use the STM32F4-Discovery board for the I2C master, so we pick the STM32F407VG device:\"\"<\/a><\/li>\n
  5. Select the basic “LEDBlink” example on the next page. As we will be replacing the main()<\/strong> function with our own code, proceed with the default LED port settings even if they don’t match your board:\"\"<\/a><\/li>\n
  6. Select debug settings that match your board and click “Finish” to create the project:\"\"<\/a><\/li>\n
  7. The I2C protocol uses 2 physical signals: SCL<\/strong> (clock) and SDA<\/strong> (data). Open the datasheet (not reference manual) for your device and locate the pins that could be used for the I2C signals. In this example, we will use the pins PB6 and PB9 (both would need to be switched to the AF4 mode):\"\"<\/a><\/li>\n
  8. Add the following function to your main file that will enable the GPIOB port and switch the PB6 and PB9 pins to the AF4 mode (I2C):\n
    void ConfigureI2CPins()\r\n{\r\n    GPIO_InitTypeDef GPIO_InitStruct;\r\n\r\n    GPIO_InitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_9;\r\n    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;\r\n    GPIO_InitStruct.Pull = GPIO_PULLUP;\r\n    GPIO_InitStruct.Speed = GPIO_SPEED_FAST;\r\n    GPIO_InitStruct.Alternate = GPIO_AF4_I2C1;\r\n    __GPIOB_CLK_ENABLE();\r\n    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);\r\n}<\/pre>\n<\/li>\n
  9. Before we can start using the I2C peripheral from our code, we need to enable its clock by calling _I2C1_CLK_ENABLE()<\/strong> and configure it by calling HAL_I2C_Init()<\/strong>. To do this, replace the contents of your main() function with the following code:\n
        HAL_Init();\r\n    ConfigureI2CPins();\r\n\r\n    I2C_HandleTypeDef hI2C = I2C_HandleTypeDef();\r\n\r\n    hI2C.Instance = I2C1;\r\n    hI2C.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;\r\n    hI2C.Init.ClockSpeed = 10240;\r\n    hI2C.Init.DutyCycle = I2C_DUTYCYCLE_2;\r\n\r\n    __I2C1_CLK_ENABLE();\r\n\r\n    if (HAL_I2C_Init(&hI2C) != HAL_OK)\r\n        asm(\"bkpt 255\");<\/pre>\n
    The HAL_I2C_Init()<\/strong> function included in the STM32 SDK will automatically read the high-level parameters, such as AddressingMode<\/strong>, and will configure the I2C hardware accordingly. Below is an overview of the main I2C configuration parameters passed to HAL_I2C_Init(). <\/strong>Note that we have selected the 7-bit addressing mode, each I2C transmission will start with a byte consisting of a 7-bit address and 1 direction bit (specifying whether it’s a read or a write). We will explain this in detail later in the tutorial.<\/li>\n
  10. Finally, add the following code to actually transmit some sample data over I2C and build the project via Build->Build Solution:\n
        if (HAL_I2C_Master_Transmit(&hI2C, 0x5A, (uint8_t *)\"1234\", 4, 10000) != HAL_OK)\r\n    {\r\n        asm(\"bkpt 255\");\r\n    }<\/pre>\n
    \"\"<\/a><\/li>\n
  11. Set a breakpoint on the HAL_I2C_Master_Transmit() call and press F5 to start debugging. Once the brekapoint triggers, the device will be ready to send the data via the I2C interface:\"\"<\/a><\/li>\n
  12. Before we create an I2C slave<\/strong> firmware for the second board (that would accept transmissions from the I2C master<\/strong>), we will use a logic analyzer to have a detailed look into the I2C signals. In this tutorial, we will use Analyzer2Go<\/a> to sample the I2C signals using a third STM32 board. Launch Analyzer2Go and select your the board you want to use as a logic analyzer from the list: \"\"<\/a><\/li>\n
  13. Press OK to initialize the board. Analyzer2Go will show the ports that could be used a inputs. Connect the SCL and SDA signals (PB6 and PB9 in this tutorial) to the logic analyzer inputs and make sure that both USB ports of the logic analyzer boards are connected to your computer:\"\"<\/a>
    \nIt is also recommended to connect the ground signals of both boards, even if they are connected to the same USB controller.<\/li>\n
  14. Enable the logic analyzer inputs that are connected to the I2C signals and name them (e.g. SCL and SDA). Then press the Record<\/strong> button to begin continuous recording:
    \n    \"\"<\/a><\/li>\n
  15. Once Analyzer2Go is recording, step over the HAL_I2C_Master_Transmit()<\/strong> call. The call will return an error and Analyzer2Go will display some activity on the SCL and SDA pins:
    \n    \"\"<\/a><\/li>\n
  16. Stop the recording, click on the magnifying lens symbol on the SCL signal to automatically zoom to a meaningful display, and switch to the Protocol Analyzers page in Analyzer2Go:\"\"<\/a><\/li>\n
  17. Drag the I2C analyzer to the Protocol Analyzers area and connect its inputs. Analyzer2Go will decode the I2C transmission, showing how it consists of a START<\/strong> bit, a WRITE<\/strong> request at address of 0x5A followed by a NAK<\/strong>, that caused the HAL_I2C_Master_Transmit()<\/strong> call to fail:\"\"<\/a><\/li>\n
  18. Switch the SDA view to raw to examine what exactly is going on with the SCL and SDA signals:
    \n    \"\"<\/a>
    \nThe I2C master begins the transmission by setting the SDA<\/strong> signal to 0, then transmits 7 address bits (0101101<\/strong>) followed by 0<\/strong> indicating a write. Then it waits for the slave to acknowledge the transmission by holding the SDA<\/strong> at 0 after the direction bit. As there is no slave connected to the master yet, the SDA line remains high, indicating a NAK.
    \nNote that the address passed to HAL_I2C_Master_Transmit() <\/strong>is aligned to the left per ST’s documentation. This means that the least significant bit<\/strong> of the 8-bit value passed to the function is always replaced by the direction bit. I.e. writing to address 0x5B\u00a0<\/strong>(01011011<\/strong><\/span>) would be equivalent to writing to 0x5A<\/strong> (01011010<\/strong><\/span>).<\/li>\n
  19. Now we will connect the I2C slave board that will receive the data from the master board. Pick a board that has I2C pins exposed and make a note of their numbers and locations. In this tutorial, we will use the STM32F410-Nucleo board, that has the I2C signals on the PB6 and PB8 pins:
    \n\n\n\n\n\n
    Signal<\/td>\nSTM32F4-Discovery<\/td>\nSTM32F410RB-Nucleo<\/td>\n<\/tr>\n
    SCL<\/td>\nPB6<\/td>\nPB8 (CN10, Pin 3)<\/td>\n<\/tr>\n
    SDA<\/td>\nPB9<\/td>\nPB9 (CN10, Pin 5)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/li>\n
  20. Connect both boards used for I2C to the USB and make sure the SCL\/SDA signals and ground are connected:\"\"<\/a><\/li>\n
  21. Now we will create a project for the I2C Slave board. Open another Visual Studio instance and launch the VisualGDB Embedded Project Wizard again:\"\"<\/a><\/li>\n
  22. Pick the device for your second board, and otherwise proceed with the same settings you used when creating the Master project:\"\"<\/a><\/li>\n
  23. The basic I2C slave project has 3 differences from the I2C master project:\n