Open STMCubeIDE, and create a project, as shown below.

Select a board by clicking the Board Selector tab and scrolling down to NUCLEO-L476RG, click on that board and press Next. This is the board used in this tutorial. You can use a different Nucleo board if you have one, but be aware that things may look different — and some settings will likely need to change.

Name the project (you can use the default settings for everything else) and click Finish..

When prompted, select Yes to “Initialize all peripherals with their default mode,” as shown below.

You should now see the MCU Pinout & Configuration tab in its default state, as shown below.

Click on the PC13 pin and select Reset_State, as shown below.

Click on the PB6 pin and select I2C1_SCL, as shown below.

Click on the PB7 pin and select I2C1_SDA.

Click on the PA0 pin, and select ADC_IN5.

In the Configuration pane, expand Analog → ADC1 and and set IN5 to IN5 Single-ended. PA0 should turn green.

Click on PA5 and ensure that it is set to GPIO_Output.

Open the Clock Configuration tab, and check that peripherals (I²C1, ADC1, etc.) are running within valid clock ranges.

In the Pinout & Configuration tab → under Connectivity, click I2C1.

In the Mode window, set I2C to I2C. The PB6 and PB7 pins on the pinout GUI should turn green. After setting Mode → I2C,  leave all Parameter Settings alone (defaults are good).

Save and Generate Code.

Step 1 — Library Declarations

Open main.c

Add these files to your project:

• Core/Inc/ssd1306.h

  ssd1306.h is the header file for the OLED helper driver. It declares the functions and constants you’ll use in your application — things like ssd1306_init(), ssd1306_clear(), ssd1306_update(), ssd1306_drawBitmap(), and ssd1306_writeString(). By including this file in main.c, you can call those high-level routines without worrying about the low-level I²C command bytes. It also defines the screen dimensions (SSD1306_WIDTH, SSD1306_HEIGHT) so your code knows the display’s resolution.

• Core/Src/ssd1306.c  

  ssd1306.c is the implementation file for the OLED helper driver. It contains the actual code that talks to the SSD1306 controller over I²C — handling initialization, maintaining the screen buffer in RAM, and sending pixel or text data to the display. Functions like ssd1306_init(), ssd1306_clear(), ssd1306_update(), ssd1306_drawBitmap(), and ssd1306_writeString() live here, turning your high-level draw calls into the proper sequence of bytes the OLED understands.

Step 2 — Include the Logo File

Include the logo file generated from the Image Processing section above. To do this we have to add the file to the Inc folder , (just drag and drop it into the folder) and we need to include it in our main.c code.

• 
  #include "logo_bmp.h"

Step 3 — Globals, Types, and Function Prototypes

This step sets up the project-wide pieces that everything else leans on:

• ScreenMode enum — defines two states (SCREEN_LOGO, SCREEN_ADC) so we can flip between screens.

  STM32 Snippet

  Copy (no comments)

  /* Private typedef -----------------------------------------------------------*/
  /* USER CODE BEGIN PTD */
  typedef enum {
    SCREEN_LOGO = 0,
    SCREEN_ADC  = 1
  } ScreenMode;
  /* USER CODE END PTD */
  
  /* Private define ------------------------------------------------------------*/
    

  typedef enum { SCREEN_LOGO = 0, SCREEN_ADC = 1 } ScreenMode;

• g_screenMode — the actual variable holding the current mode (starts on logo).

• g_lastChangeMs —“activity timer,” refreshed whenever the pot moves enough

• g_lastAdcCounts — baseline value, so we can measure deltas.

• ADC_DELTA — baseline value, so we can measure deltas.

• g_oledAddr — holds the OLED I²C address (default 0x3C, some modules use 0x3D).

  STM32 Snippet

  Copy (no comments)

  /* USER CODE BEGIN PV */
  volatile ScreenMode g_screenMode = SCREEN_LOGO; 
  // Current screen: logo or ADC view
  
  volatile uint32_t g_lastChangeMs = 0;  
  // Timestamp (ms) of last significant ADC change (for 4s auto-return)
  
  volatile uint32_t g_lastAdcCounts = 0; 
  // Baseline ADC sample for delta comparisons
  
  const uint16_t ADC_DELTA = 30;         
  // Threshold in ADC counts to consider a “significant” change
  
  uint8_t g_oledAddr = 0x3C;             
  // OLED I2C address (7-bit). ProbeOledAddress() may change this to 0x3D at startup.
  /* USER CODE END PV */
  
    

  volatile ScreenMode g_screenMode = SCREEN_LOGO; volatile uint32_t g_lastChangeMs = 0; volatile uint32_t g_lastAdcCounts = 0; const uint16_t ADC_DELTA = 30; uint8_t g_oledAddr = 0x3C;

And we declare a few function prototypes so the compiler knows what’s coming later:

• RenderLogo() — clears the OLED and draws the splash bitmap.

• RenderADC() — reads the potentiometer voltage and prints it.

• ErrorBlink() — flashes the onboard LED if something goes wrong.

• ProbeOledAddress()) — makes startup robust to OLEDs shipping at 0x3C vs 0x3D.

• AdcCountsToVolts() — neat little math helper (keeps RenderADC() tidy).

• CheckAdcForChange() — called in the main loop to detect when the pot moved enough to warrant switching to SCREEN_ADC.

  STM32 Snippet

  Copy (no comments)

  /* USER CODE BEGIN PFP */
  void RenderLogo(void);           // Clear OLED and draw splash bitmap
  void RenderADC(void);            // Read ADC, convert to volts, and display on OLED
  void ErrorBlink(void);           // Flash LD2 on PA5 to indicate error
  static uint8_t ProbeOledAddress(void); // Scan I2C bus for OLED at 0x3C/0x3D
  static float AdcCountsToVolts(uint32_t counts, float vref, uint16_t fullscale);
  // Convert raw ADC counts to a voltage value
  static void CheckAdcForChange(void);   // Poll ADC; flip to ADC mode on significant delta
  /* USER CODE END PFP */
    

  void RenderLogo(void); void RenderADC(void); void ErrorBlink(void); static uint8_t ProbeOledAddress(void); static float AdcCountsToVolts(uint32_t counts, float vref, uint16_t fullscale); static void CheckAdcForChange(void);

Step 4 — Main Function Skeleton

This is where all the pieces come together for the first time. The code in step one is auto generated, so just confirm that those pieces are there. The main() function provides the program’s backbone:

• System bring-up (Auto generated)

  • Call HAL_Init() and SystemClock_Config() to get the MCU running.

  • Initialize peripherals through the Cube-generated functions (MX_GPIO_Init(), MX_I2C1_Init(), MX_ADC1_Init(), etc.).

    

• OLED startup

  • Probe for the OLED’s I²C address (ProbeOledAddress()), since different modules ship with either 0x3C or 0x3D. This code should be placed just after the MX_XX_init() function calls, in the USER CODE BEGIN 2 section.

    STM32 Snippet

    Copy (no comments)

      /* USER CODE BEGIN 2 */
     
      
      // Probe OLED address (required; fail fast if not found)
       uint8_t probed = ProbeOledAddress();   // checks 0x3C / 0x3D
       if (!probed) {
         // OLED not detected: signal error and stop here
         ErrorBlink();                         // brief LED flash pattern
         while (1) {                           // hard-stop; no pointless init/draw
           HAL_Delay(250);
         }
       }
       g_oledAddr = probed;
      
      /* USER CODE END 2 */
      

    uint8_t probed = ProbeOledAddress(); if (!probed) { ErrorBlink(); while (1) { HAL_Delay(250); } } g_oledAddr = probed;

  • Initialize the OLED with ssd1306_init(), however, if init fails blink forever. This shold go right under the previouse code, in the same section.

    STM32 Snippet

    Copy (no comments)

    /* USER CODE BEGIN PV */
    volatile ScreenMode g_screenMode = SCREEN_LOGO; 
    // Tracks which screen is active: logo or ADC view
    
    volatile uint32_t g_lastChangeMs = 0;  
    // Timestamp (ms) of the last significant ADC change, used for 4s auto-return
    
    volatile uint32_t g_lastAdcCounts = 0; 
    // Stores the last ADC sample as a baseline for detecting changes
    
    const uint16_t ADC_DELTA = 30;         
    // Threshold: how many counts must change before we switch to ADC view
    
    /* USER CODE END PV */
      

    volatile ScreenMode g_screenMode = SCREEN_LOGO; volatile uint32_t g_lastChangeMs = 0; volatile uint32_t g_lastAdcCounts = 0; const uint16_t ADC_DELTA = 30;

  • Immediately show your splash screen by calling RenderLogo() so the user sees something on power-up. This should be placed right after the ssd1306_init code, in the same section.

    STM32 Snippet

    Copy (no comments)

      //  Initial screen
      RenderLogo();
      

    RenderLogo();

• Main loop

  Once everything is initialized, the program lives inside the while(1) loop. Here, a simple switch on g_screenMode decides what the OLED should show:

  SCREEN_LOGO case

  • The display already holds the splash screen, so we don’t need to redraw it every cycle.

  • We just poll the ADC lightly with CheckAdcForChange(). If the potentiometer moves far enough (beyond ADC_DELTA), this function flips the mode to SCREEN_ADC and records the time of change.

  • Otherwise, the loop idles with a short HAL_Delay(50) to keep things responsive without hogging the CPU

  SCREEN_ADC case

  • The OLED is actively updated with the current ADC reading every ~100 ms using RenderADC().

  • CheckAdcForChange() continues running in this mode as well, so the “last activity” timer refreshes as long as the knob keeps moving.

  • If no significant ADC change occurs for about 4 seconds (checked with HAL_GetTick() vs. g_lastChangeMs), the code switches back to SCREEN_LOGO and immediately redraws the splash screen.

  Default case

  • A safety net: if g_screenMode somehow takes on an invalid value, reset it back to SCREEN_LOGO and redraw the splash.

  STM32 Snippet

  Copy (no comments)

  
  
  /* USER CODE BEGIN 3 */
      switch (g_screenMode)
      {
        case SCREEN_LOGO:
          // Light polling to detect a “significant” change and flip to ADC
          CheckAdcForChange();
          HAL_Delay(50);
          break;
  
        case SCREEN_ADC:
          // Keep it feeling live; also keep polling to refresh the 4s window
          RenderADC();
          CheckAdcForChange(); // if the knob keeps moving, window refreshes
          HAL_Delay(100);
  
          // Auto-return to logo after ~4 s of no significant changes
          if (HAL_GetTick() - g_lastChangeMs >= 4000U) {
            g_screenMode = SCREEN_LOGO;
            RenderLogo();
          }
          break;
  
        default:
          g_screenMode = SCREEN_LOGO;
          RenderLogo();
          break;
      }
    
   /* USER CODE END 3 */
    

  switch (g_screenMode) { case SCREEN_LOGO: CheckAdcForChange(); HAL_Delay(50); break; case SCREEN_ADC: RenderADC(); CheckAdcForChange(); HAL_Delay(100); if (HAL_GetTick() - g_lastChangeMs >= 4000U) { g_screenMode = SCREEN_LOGO; RenderLogo(); } break; default: g_screenMode = SCREEN_LOGO; RenderLogo(); break; }

Step 5 — Function Definitions

Place these function defintions in the /* USER CODE BEGIN 4 */ section, near the bottom.

• RenderLogo() – clear, draw logoBitmap from logo.h, ssd1306_update().

• RenderADC() – read ADC once, compute volts with AdcCountsToVolts(), print lines, ssd1306_update().

• AdcCountsToVolts() – (vref * counts) / fullscale (4095 for 12‑bit).

• CheckAdcForChange()– poll ADC, if abs(delta) >= ADC_DELTA, set g_screenMode = SCREEN_ADC and refresh g_lastChangeMs.

• ProbeOledAddress() – try 0x3C/0x3D; return found address or 0 on fail.

• ErrorBlink()– flash PA5 (LD2) on failures.

  STM32 Snippet

  Copy (no comments)

  /* USER CODE BEGIN 4 */
  
  // ---- Render the splash/logo bitmap ----
  void RenderLogo(void)
  {
    ssd1306_clear();
    // Draw at top-left; adjust x,y to center if desired
    ssd1306_drawBitmap(0, 0, logoBitmap, logoWidth, logoHeight);
    ssd1306_update();
  }
  
  // ---- Render live ADC readout ----
  void RenderADC(void)
  {
    // 1) One blocking sample (simple + sufficient for UI rates)
    HAL_ADC_Start(&hadc1);
    if (HAL_ADC_PollForConversion(&hadc1, 5) != HAL_OK) {
      HAL_ADC_Stop(&hadc1);
      ErrorBlink();
      return;
    }
    uint32_t counts = HAL_ADC_GetValue(&hadc1);
    HAL_ADC_Stop(&hadc1);
  
    // 2) Convert counts → volts (12-bit full-scale by default)
    const float VREF      = 3.300f;  // adjust if you use a different analog reference
    const uint16_t FS_12B = 4095U;
    float volts = AdcCountsToVolts(counts, VREF, FS_12B);
  
    // 3) Draw to OLED
    char line1[32];
    char line2[32];
    snprintf(line1, sizeof(line1), "ADC: %4lu", (unsigned long)counts);
    snprintf(line2, sizeof(line2), "V  : %1.3f", (double)volts);
  
    ssd1306_clear();
    ssd1306_writeString(8,  12, "Potentiometer", Font_7x10, 1);
    ssd1306_writeString(8,  32, line1,          Font_7x10, 1);
    ssd1306_writeString(8,  46, line2,          Font_7x10, 1);
    ssd1306_update();
  }
  
  // ---- Blink LD2 on PA5 as a simple error indicator ----
  void ErrorBlink(void)
  {
    for (int i = 0; i < 6; ++i) {
      HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
      HAL_Delay(100);
    }
  }
  
  // ---- Probe for OLED I2C address (returns 7-bit: 0x3C or 0x3D; 0 if not found) ----
  static uint8_t ProbeOledAddress(void)
  {
    const uint8_t candidates[] = { 0x3C, 0x3D };     // common SSD1306 7-bit addresses
    for (size_t i = 0; i < sizeof(candidates); ++i) {
      // HAL expects the 8-bit address (7-bit << 1)
      uint16_t addr8 = (uint16_t)(candidates[i] << 1);
      if (HAL_I2C_IsDeviceReady(&hi2c1, addr8, 1, 10) == HAL_OK) {
        return candidates[i]; // return 7-bit form to store in g_oledAddr
      }
    }
    return 0; // not found
  }
  
  // ---- Convert raw ADC counts to volts ----
  static float AdcCountsToVolts(uint32_t counts, float vref, uint16_t fullscale)
  {
    if (counts > fullscale) counts = fullscale;
    return (vref * (float)counts) / (float)fullscale;
  }
  
  // ---- Poll ADC; flip to ADC screen on “significant” change ----
  static void CheckAdcForChange(void)
  {
    HAL_ADC_Start(&hadc1);
    if (HAL_ADC_PollForConversion(&hadc1, 5) != HAL_OK) {
      HAL_ADC_Stop(&hadc1);
      return;
    }
    uint32_t counts = HAL_ADC_GetValue(&hadc1);
    HAL_ADC_Stop(&hadc1);
  
    // Compare to baseline
    uint32_t prev = g_lastAdcCounts;
    uint32_t diff = (counts > prev) ? (counts - prev) : (prev - counts);
  
    if (diff >= ADC_DELTA) {
      g_lastAdcCounts = counts;         // update baseline
      g_screenMode    = SCREEN_ADC;     // request ADC view
      g_lastChangeMs  = HAL_GetTick();  // refresh 4s “activity” timer
    }
  }
  
  /* USER CODE END 4 */
  
    

  void RenderLogo(void) { ssd1306_clear(); ssd1306_drawBitmap(0, 0, logoBitmap, logoWidth, logoHeight); ssd1306_update(); } void RenderADC(void) { HAL_ADC_Start(&hadc1); if (HAL_ADC_PollForConversion(&hadc1, 5) != HAL_OK) { HAL_ADC_Stop(&hadc1); ErrorBlink(); return; } uint32_t counts = HAL_ADC_GetValue(&hadc1); HAL_ADC_Stop(&hadc1); const float VREF = 3.300f; const uint16_t FS_12B = 4095U; float volts = AdcCountsToVolts(counts, VREF, FS_12B); char line1[32]; char line2[32]; snprintf(line1, sizeof(line1), "ADC: %4lu", (unsigned long)counts); snprintf(line2, sizeof(line2), "V : %1.3f", (double)volts); ssd1306_clear(); ssd1306_writeString(8, 12, "Potentiometer", Font_7x10, 1); ssd1306_writeString(8, 32, line1, Font_7x10, 1); ssd1306_writeString(8, 46, line2, Font_7x10, 1); ssd1306_update(); } void ErrorBlink(void) { for (int i = 0; i < 6; ++i) { HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); HAL_Delay(100); } } static uint8_t ProbeOledAddress(void) { const uint8_t candidates[] = { 0x3C, 0x3D }; for (size_t i = 0; i < sizeof(candidates); ++i) { uint16_t addr8 = (uint16_t)(candidates[i] << 1); if (HAL_I2C_IsDeviceReady(&hi2c1, addr8, 1, 10) == HAL_OK) { return candidates[i]; } } return 0; } static float AdcCountsToVolts(uint32_t counts, float vref, uint16_t fullscale) { if (counts > fullscale) counts = fullscale; return (vref * (float)counts) / (float)fullscale; } static void CheckAdcForChange(void) { HAL_ADC_Start(&hadc1); if (HAL_ADC_PollForConversion(&hadc1, 5) != HAL_OK) { HAL_ADC_Stop(&hadc1); return; } uint32_t counts = HAL_ADC_GetValue(&hadc1); HAL_ADC_Stop(&hadc1); uint32_t prev = g_lastAdcCounts; uint32_t diff = (counts > prev) ? (counts - prev) : (prev - counts); if (diff >= ADC_DELTA) { g_lastAdcCounts = counts; g_screenMode = SCREEN_ADC; g_lastChangeMs = HAL_GetTick(); } }