STM32 Blue Pill with SH1107 OLED Display – I2C Mode Example

Leave a Comment / By Simple Projects / March 7, 2025

This STM32 project shows how to interface the STM32 Blue Pill board with SH1107 monochrome OLED display module that has a size of 1.5-inch and resolution of 128×128 pixel.
The example shows how to print texts and draw some shapes (circles, rectangular…) on the SH1107 OLED display which is configured to work in I2C mode.

The STM32 Blue Pill development board is based on STMicroelectronics ARM Cortex-M3 microcontroller STM32F103C8T6 running at maximum clock frequency of 72MHz. This particular development board gained popularity due to its low cost and compact size, making it a popular choice for hobbyists, students, and developers.

To use the STM32 Blue Pill, a hardware programmer, such as ST-Link, is required to upload project code to the board. A USB-to-Serial converter module can also be used to upload the code to the board, an example of this converter is the popular one from FTDI which is FT232RL module.

Abbreviations:
OLED: Organic light Emitting Diode.
PLED: Polymer OLED.
TFT: Thin Film Transistor.
I2C: Inter-Integrated Circuit.
SPI: Serial Peripheral Interface.
IoT: Internet of things.

The SH1107 OLED Display Module:
The SH1107 chip is a CMOS OLED/PLED driver with controller commonly used in small to medium-sized Organic/Polymer light-emitting diode dot-matrix display systems.
The SH1107 chip supports a maximum display resolution of 128×128 pixel and it is designed to drive monochrome OLED panels and is widely used in embedded systems, IoT devices, and consumer electronics.

The SH1107 OLED display module is a compact monochrome graphic display module that uses the SH1107 driver chip. These display modules are typically 128×64 or 128×128 pixels and are commonly available in I2C or SPI communication interfaces. These displays are commonly found in small, low-power devices as they have high contrast, wide viewing angles, and compact size. They are often used in projects involving microcontrollers like Arduino, ESP32, Raspberry Pi, and others.

Properties of the SH1107 OLED Displays Modules:

Resolution: Usually 128×64 or 128×128 pixels, smaller resolutions may be also available.
Display Type: Monochrome (one color only that usually white, blue, or yellow pixels on a black background).
Interface: Usually supports I2C and/or SPI communication with the I2C be the most common interface.
Operating Voltage: Usually 3.3V or 5V, depending on the module.
Power Consumption: Very low power usage as the display does not require backlight, making it ideal for battery-powered devices.

The SH1107 OLED display module used in this project is shown below:

The SH1107 OLED display shown above works with I2C interface protocol only. Below is the pinout for the display module, which is essential for connecting it to a microcontroller like Arduino, ESP32, Raspberry Pi, or Microchip PIC/dsPIC:

VCC: Power supply pin, may be 3.3V or 5V (refer to your display datasheet for power supply voltage range, some modules works only with 3.3V).
GND: Ground pin, connected to circuit common ground.
SCL: Serial Clock line of the I2C bus.
SDA: Serial Data line of the I2C bus.

The default I2C address of this module is 0x3C, but we can change it to 0x3D by shorting resistor R31, or removing resistor R30 (10k) and placing it on R31 (see the image below).
Also, if you’re using the same SH1107 display module shown above, it will be more better to change resistors R26 and R27 (1k each) by another ones not exceeding 100 Ohm (for example use 33 Ohm), or simply short each one of them.

Note that some SH1107 display modules supports both interfaces I2C and SPI where the user can choose between the two protocols with few changes in the module PCB (for example closing and/or opening jumpers).

Interfacing STM32 Blue Pill Board with SH1107 OLED Display – I2C Mode Example:
This post shows how to easily interface STM32 Blue Pill with SH1107 OLED display where the development board is connected to the display module via I2C interface.
Example circuit schematic is shown below.

The SH1107 OLED display module used in this project has 4 pins connected to the STM32 Blue Pill board as follows:
GND pin is connected to GND pin of the STM32 board.
VCC pin is connected to 3.3V pin of the STM32 board.
SCL (I2C Serial clock) pin is connected to pin B6 of the STM32 board.
SDA (I2C Serial data) pin is connected to pin B7 of the STM32 board.

Note that pins B6 and B7 of the STM32 Blue Pill board are hardware I2C pins of the microcontroller STM32F103C8T6, respectively for SCL and SDA lines.

Hardware Required:
This is a summary of the parts required to build this project.

STM32 Blue Pill board —> STM32F103C8T6 32-bit Arm Cortex-M3 MCU datasheet
SH1107 OLED display module
Bread board & Jumper wires
STM32 Microcontroller programmer (ST-Link, USB-to-Serial converter…)

Interfacing STM32 Blue Pill Board with SH1107 OLED Display Code:
Arduino IDE (Integrated Development Environment) is used to write project code, the STM32 Blue Pill board has to be added to the IDE before compiling the code.
The STM32 Blue Pill board can be installed using Arduino IDE Boards Manager.

The FT232RL USB to serial UART converter is used to program the STM32F103C8T6 microcontroller, the ST-LINK V2 programmer also can be used and it is supported by Arduino IDE.

To be able to compile project Arduino code, two libraries are required from Adafruit Industries:
The first library is a driver for the SH1107 OLED display and it can be installed from Arduino IDE library manager (Sketch —> Include Library —> Manage Libraries…, in the search box write “sh1107” and install the one from Adafruit).
The second library is Adafruit graphics library which can be installed also from Arduino IDE library manager.
During installation of the Adafruit SH1107 library, Arduino IDE may ask for installing some other libraries form Adafruit Industries (dependencies).

Project code was tested with the following library versions:
Adafruit GFX Library: Version 1.12.0.
Adafruit SH110X OLED display Library: Version 2.1.12.
Adafruit BusIO: Version 1.17.0.

Programming Hints:
The used libraries are included in the Arduino code as shown below:

#include <Wire.h> // Wire library

#include <Adafruit_GFX.h> // Adafruit Graphics library

#include <Adafruit_SH110X.h> // Adafruit SH110x display driver

The SH1107 display library is initialized with width of 128 pixel & height of 128 pixel, and I2C clock frequency of 400kHz:

#define SCREEN_WIDTH 128 // OLED display width, in pixels

#define SCREEN_HEIGHT 128 // OLED display height, in pixels

#define OLED_RESET -1 // can set an oled reset pin if desired

Adafruit_SH1107 display = Adafruit_SH1107(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET, 400000, 100000);

The SH1107 OLED display must be initialized before any print operation, if the initialization failed then the display will show only black screen. The initialization function of the display is the one below with I2C address of 0x3C:

1	display.begin(0x3C, true); // If the display shows no thing then try with address 0x3D

Note that the Arduino code given below is originally comes as an example with the Adafruit SH1107 library. Minor modification are made to the original code.

Full Arduino code:

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

/******************************************************************************

* Interfacing STM32 Blue Pill board with SH1107 OLED monochrome display.

* The SSH1107 OLED resolution is 128×128 Pixel and it is configured to work

* in I2C mode with address 0x3C (0x78).

* This is a free software with NO WARRANTY.

* https://simple-circuit.com/

/*******************************************************************************/

#include <Wire.h> // Wire library

#include <Adafruit_GFX.h> // Adafruit Graphics library

#include <Adafruit_SH110X.h> // Adafruit SH110x display driver

#define SCREEN_WIDTH 128 // OLED display width, in pixels

#define SCREEN_HEIGHT 128 // OLED display height, in pixels

#define OLED_RESET -1 // can set an oled reset pin if desired

Adafruit_SH1107 display = Adafruit_SH1107(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET, 400000, 100000);

#define LOGO_HEIGHT 16

#define LOGO_WIDTH 16

static const unsigned char PROGMEM logo_bmp[] =

{ 0b00000000, 0b11000000,

0b00000001, 0b11000000,

0b00000011, 0b11100000,

0b11110011, 0b11100000,

0b11111110, 0b11111000,

0b01111110, 0b11111111,

0b00110011, 0b10011111,

0b00011111, 0b11111100,

0b00001101, 0b01110000,

0b00011011, 0b10100000,

0b00111111, 0b11100000,

0b00111111, 0b11110000,

0b01111100, 0b11110000,

0b01110000, 0b01110000,

0b00000000, 0b00110000 };

void setup() {

Serial.begin(9600);

delay(500); // wait for the OLED to power up

// Show image buffer on the display hardware.

// Since the buffer is intialized with an Adafruit splashscreen

// internally, this will display the splashscreen.

display.begin(0x3C, true); // If the display shows no thing then try with address 0x3D

//display.setContrast (0); // dim display

display.display();

delay(2000);

// Clear the buffer.

display.clearDisplay();

// draw a single pixel

display.drawPixel(10, 10, SH110X_WHITE);

// Show the display buffer on the hardware.

// NOTE: You _must_ call display after making any drawing commands

// to make them visible on the display hardware!

display.display();

delay(2000);

display.clearDisplay();

testdrawline(); // Draw many lines

testdrawrect(); // Draw rectangles (outlines)

testfillrect(); // Draw rectangles (filled)

testdrawcircle(); // Draw circles (outlines)

testfillcircle(); // Draw circles (filled)

testdrawroundrect(); // Draw rounded rectangles (outlines)

testfillroundrect(); // Draw rounded rectangles (filled)

testdrawtriangle(); // Draw triangles (outlines)

testfilltriangle(); // Draw triangles (filled)

testdrawchar(); // Draw characters of the default font

testdrawstyles(); // Draw ‘stylized’ characters

testdrawbitmap(); // Draw a small bitmap image

testanimate(logo_bmp, LOGO_WIDTH, LOGO_HEIGHT); // Animate bitmaps

}

void loop() {

}

void testdrawline() {

int16_t i;

display.clearDisplay(); // Clear display buffer

for(i=0; i<display.width(); i+=4) {

display.drawLine(0, 0, i, display.height()–1, SH110X_WHITE);

display.display(); // Update screen with each newly-drawn line

delay(1);

}

for(i=0; i<display.height(); i+=4) {

display.drawLine(0, 0, display.width()–1, i, SH110X_WHITE);

display.display();

delay(1);

}

delay(250);

display.clearDisplay();

for(i=0; i<display.width(); i+=4) {

display.drawLine(0, display.height()–1, i, 0, SH110X_WHITE);

display.display();

delay(1);

}

for(i=display.height()–1; i>=0; i-=4) {

display.drawLine(0, display.height()–1, display.width()–1, i, SH110X_WHITE);

display.display();

delay(1);

}

delay(250);

display.clearDisplay();

for(i=display.width()–1; i>=0; i-=4) {

display.drawLine(display.width()–1, display.height()–1, i, 0, SH110X_WHITE);

display.display();

delay(1);

}

for(i=display.height()–1; i>=0; i-=4) {

display.drawLine(display.width()–1, display.height()–1, 0, i, SH110X_WHITE);

display.display();

delay(1);

}

delay(250);

display.clearDisplay();

for(i=0; i<display.height(); i+=4) {

display.drawLine(display.width()–1, 0, 0, i, SH110X_WHITE);

display.display();

delay(1);

}

for(i=0; i<display.width(); i+=4) {

display.drawLine(display.width()–1, 0, i, display.height()–1, SH110X_WHITE);

display.display();

delay(1);

}

delay(2000); // Pause for 2 seconds

}

void testdrawrect(void) {

display.clearDisplay();

for(int16_t i=0; i<display.height()/2; i+=2) {

display.drawRect(i, i, display.width()–2*i, display.height()–2*i, SH110X_WHITE);

display.display(); // Update screen with each newly-drawn rectangle

delay(1);

}

delay(2000);

}

void testfillrect(void) {

display.clearDisplay();

for(int16_t i=0; i<display.height()/2; i+=3) {

// The INVERSE color is used so rectangles alternate white/black

display.fillRect(i, i, display.width()–i*2, display.height()–i*2, SH110X_INVERSE);

display.display(); // Update screen with each newly-drawn rectangle

delay(1);

}

delay(2000);

}

void testdrawcircle(void) {

display.clearDisplay();

for(int16_t i=0; i<max(display.width(),display.height())/2; i+=2) {

display.drawCircle(display.width()/2, display.height()/2, i, SH110X_WHITE);

display.display();

delay(1);

}

delay(2000);

}

void testfillcircle(void) {

display.clearDisplay();

for(int16_t i=max(display.width(),display.height())/2; i>0; i-=3) {

// The INVERSE color is used so circles alternate white/black

display.fillCircle(display.width() / 2, display.height() / 2, i, SH110X_INVERSE);

display.display(); // Update screen with each newly-drawn circle

delay(1);

}

delay(2000);

}

void testdrawroundrect(void) {

display.clearDisplay();

for(int16_t i=0; i<display.height()/2–2; i+=2) {

display.drawRoundRect(i, i, display.width()–2*i, display.height()–2*i,

display.height()/4, SH110X_WHITE);

display.display();

delay(1);

}

delay(2000);

}

void testfillroundrect(void) {

display.clearDisplay();

for(int16_t i=0; i<display.height()/2–2; i+=2) {

// The INVERSE color is used so round-rects alternate white/black

display.fillRoundRect(i, i, display.width()–2*i, display.height()–2*i,

display.height()/4, SH110X_INVERSE);

display.display();

delay(1);

}

delay(2000);

}

void testdrawtriangle(void) {

display.clearDisplay();

for(int16_t i=0; i<max(display.width(),display.height())/2; i+=5) {

display.drawTriangle(

display.width()/2 , display.height()/2–i,

display.width()/2–i, display.height()/2+i,

display.width()/2+i, display.height()/2+i, SH110X_WHITE);

display.display();

delay(1);

}

delay(2000);

}

void testfilltriangle(void) {

display.clearDisplay();

for(int16_t i=max(display.width(),display.height())/2; i>0; i-=5) {

// The INVERSE color is used so triangles alternate white/black

display.fillTriangle(

display.width()/2 , display.height()/2–i,

display.width()/2–i, display.height()/2+i,

display.width()/2+i, display.height()/2+i, SH110X_INVERSE);

display.display();

delay(1);

}

delay(2000);

}

void testdrawchar(void) {

display.clearDisplay();

display.setTextSize(1); // Normal 1:1 pixel scale

display.setTextColor(SH110X_WHITE); // Draw white text

display.setCursor(0, 0); // Start at top-left corner

display.cp437(true); // Use full 256 char ‘Code Page 437’ font

// Not all the characters will fit on the display. This is normal.

// Library will draw what it can and the rest will be clipped.

for(int16_t i=0; i<256; i++) {

if(i == ‘\n’) display.write(‘ ‘);

else display.write(i);

}

display.display();

delay(2000);

}

void testdrawstyles(void) {

display.clearDisplay();

display.setTextSize(1); // Normal 1:1 pixel scale

display.setTextColor(SH110X_WHITE); // Draw white text

display.setCursor(0,0); // Start at top-left corner

display.println(F(“Hello, world!”));

display.setTextColor(SH110X_BLACK, SH110X_WHITE); // Draw ‘inverse’ text

display.println(3.141592);

display.setTextSize(2); // Draw 2X-scale text

display.setTextColor(SH110X_WHITE);

display.print(F(“0x”)); display.println(0xDEADBEEF, HEX);

display.display();

delay(2000);

}

void testdrawbitmap(void) {

display.clearDisplay();

display.drawBitmap(

(display.width() – LOGO_WIDTH ) / 2,

(display.height() – LOGO_HEIGHT) / 2,

logo_bmp, LOGO_WIDTH, LOGO_HEIGHT, 1);

display.display();

delay(1000);

}

#define NUMFLAKES 10

#define XPOS 0 // Indexes into the ‘icons’ array in function below

#define YPOS 1

#define DELTAY 2

#define DELTAT 3

void testanimate(const uint8_t *bitmap, uint8_t w, uint8_t h) {

uint8_t f;

int16_t icons[NUMFLAKES][4];

// Initialize ‘snowflake’ positions

for(f = 0; f < NUMFLAKES; f++) {

icons[f][XPOS] = random(1 – LOGO_WIDTH, display.width());

icons[f][YPOS] = –LOGO_HEIGHT;

icons[f][DELTAY] = random(1, 8);

icons[f][DELTAT] = 0;

Serial.print(F(“x: “));

Serial.print(icons[f][XPOS], DEC);

Serial.print(F(” y: “));

Serial.print(icons[f][YPOS], DEC);

Serial.print(F(” dy: “));

Serial.println(icons[f][DELTAY], DEC);

}

display.clearDisplay(); // Clear the display buffer

for(;;) { // Loop forever…

// Draw each snowflake:

for(f=0; f< NUMFLAKES; f++) {

icons[f][DELTAT] += 1;

if (icons[f][DELTAT] >= icons[f][DELTAY]) {

icons[f][YPOS] += 1;

icons[f][DELTAT] = 0;

display.drawBitmap(icons[f][XPOS], icons[f][YPOS] – 1, bitmap, w, h, SH110X_BLACK); // Erase the snowflake

display.drawBitmap(icons[f][XPOS], icons[f][YPOS], bitmap, w, h, SH110X_WHITE);

}

display.display(); // Show the display buffer on the screen

delay(40); // Pause for 40 ms

// Then update coordinates of each flake…

for(f = 0; f < NUMFLAKES; f++) {

//icons[f][YPOS] += icons[f][DELTAY];

// If snowflake is off the bottom of the screen…

if (icons[f][YPOS] >= (display.height())) {

// Reinitialize to a random position, just off the top

icons[f][XPOS] = random(1 – LOGO_WIDTH, display.width());

icons[f][YPOS] = –LOGO_HEIGHT;

icons[f][DELTAY] = random(1, 8);

icons[f][DELTAT] = 0;

}

// End of code.

// https://simple-circuit.com/

/*********************************************************************

This is an example for our Monochrome OLEDs based on SH1107 drivers

This example is for a 128×128 size display using I2C to communicate

Adafruit invests time and resources providing this open source code,

please support Adafruit and open-source hardware by purchasing

products from Adafruit!

Written by Limor Fried/Ladyada for Adafruit Industries.

BSD license, check license.txt for more information

All text above, and the splash screen must be included in any redistribution

*********************************************************************/

Interfacing STM32 Blue Pill Board with SH1107 OLED Display Video:
The video below shows a test circuit of the STM32 Blue Pill board with SH1107 OLED display module (I2C interface).

Related Projects:

Published by howdy