Difference between revisions of "1.3inch OLED Module (C)"

From Waveshare Wiki
Jump to: navigation, search
Line 546: Line 546:
 
   Color_Background: indicates the background color
 
   Color_Background: indicates the background color
 
</pre>
 
</pre>
==Python (for RPi)==
+
==Python(for Raspberry Pi)==
 +
It is compatible with python2.7 and python3.<br />
 +
The calls of the python are less complex compared to C demo.
 +
===config.py===
 +
*Select interface.
 +
<pre>
 +
Device_SPI = 1
 +
Device_I2C = 0
 +
Note: Switch SPI/I2C modified here
 +
</pre>
 +
*Module initialization and exit processing.
 +
<pre>
 +
def module_init()
 +
def module_exit()
 +
Note:
 +
1. Here is some GPIO processing before and after using the LCD screen.
 +
2. The module_init() function is automatically called in the INIT () initializer on the LCD, but the module_exit() function needs to be called by itself
 +
</pre>
 +
*SPI write data.
 +
def spi_writebyte(data)
 +
*IIC write data. 
 +
i2c_writebyte(reg, value):
 +
===main.py===
 +
The main function, if your Python version is Python2, is re-executed in Linux command mode as follows.
 +
sudo python main.py
 +
If your Python version is Python3, run the following command in Linux.
 +
sudo python3 main.py
 +
 
 +
===GUI functions===
 +
Python has an image library [http://effbot.org/imagingbook PIL official library link], it do not need to write code from the logical layer like C, can directly call to the image library for image processing. The following will take 1.54inch LCD as an example, we provide a brief description for the demo.
 +
*It needs to use the image library and install the library.
 +
sudo apt-get install python3-pil 
 +
And then import the library<br />
 +
from PIL import Image,ImageDraw,ImageFont.
 +
Among them, Image is the basic library, ImageDraw is the drawing function, and ImageFont is the text function.
 +
*Define an image buffer
 +
image1 = Image.new("1", (disp.width, disp.height), "WHITE")
 +
The first parameter defines the color depth of the image, which is defined as "1" to indicate the bitmap of one-bit depth. The second parameter is a tuple that defines the width and height of the image. The third parameter defines the default color of the buffer, which is defined as "WHITE".
 +
 
 +
*Create a drawing object based on Image1 on which all drawing operations will be performed on here.
 +
draw = ImageDraw.Draw(image1)
 +
*Draw line.
 +
draw.line([(0,0),(127,0)], fill = 0)
 +
The first parameter is a four-element tuple starting at (0, 0) and ending at (127,0). Draw a line. Fill ="0" means the color of the line is white.
 +
 
 +
*Draw rectangle.
 +
draw.rectangle([(20,10),(70,60)],fill = "WHITE",outline="BLACK")
 +
The first argument is a tuple of four elements. (20,10) is the coordinate value in the upper left corner of the rectangle, and (70,60) is the coordinate value in the lower right corner of the rectangle. Fill =" WHITE" means BLACK inside, and outline="BLACK" means the color of the outline is black.
 +
 
 +
*Draw circle.
 +
draw.arc((150,15,190,55),0, 360, fill =(0,255,0)
 +
Draw an inscribed circle in the square, the first parameter is a tuple of 4 elements, with (150, 15) as the upper left corner vertex of the square, (190, 55) as the lower right corner vertex of the square, specifying the level median line of the rectangular frame is the angle of 0 degrees, the second parameter indicates the starting angle, the third parameter indicates the ending angle, and fill = 0 indicates that the the color of the line is white.
 +
If the figure is not square according to the coordination, you will get an ellipse.
 +
 
 +
Besides the arc function, you can also use the chord function for drawing solid circle.
 +
draw.ellipse((150,65,190,105), fill = 0)
 +
The first parameter is the coordination of the enclosing rectangle. The second and third parameters are the beginning and end degrees of the circle. The fourth parameter is the fill color of the circle.
 +
*Character.
 +
The ImageFont module needs to be imported and instantiated:
 +
<pre>
 +
Font1 = ImageFont.truetype("../Font/Font01.ttf",25)
 +
Font2 = ImageFont.truetype("../Font/Font01.ttf",35)
 +
Font3 = ImageFont.truetype("../Font/Font02.ttf",32)
 +
</pre>
 +
You can use the fonts of Windows or other fonts which is in ttc format..<br />
 +
Note: Each character library contains different characters; If some characters cannot be displayed, it is recommended that you can refer to the encoding set ro used.
 +
To draw English character, you can directly use the fonts; for Chinese character, you need to add a symbol u:
 +
<pre>
 +
draw.text((5, 68), 'Hello world', fill = 0, font=Font1)
 +
text= u"微雪电子"
 +
draw.text((5, 200), text, fill = 0, font=Font3)
 +
</pre>
 +
The first parameter is a two-element tuple with (5,68) as the left vertex, and use font1, fill is font color, fill = 0 means that the font color is white, and the second sentence shows’微雪电子’, font color is white.
 +
*Read local picture.
 +
image = Image.open('../pic/pic.bmp')
 +
The parameter is the image path.
 +
*Other functions.
 +
For more information, you can search online.
  
 
='''STM32 guides'''=
 
='''STM32 guides'''=

Revision as of 02:47, 10 June 2022

1.3inch OLED Module (C)
1.3inch-OLED-Module (C)
{{{name2}}}

{{{name3}}}

{{{name4}}}

{{{name5}}}

Overview

1.3inch LCD HAT, SPI/I2C interfaces

Specification

  • Working Voltage:3.3V
  • Communication Interface:SPI/IIC
  • Controller:SH1107
  • Resolution:64 × 128
  • Display Area:14.7 × 29.42 (mm)
  • Pixel size:0.15 × 0.15 (mm)
  • Dimension: 30 × 39.5(mm)
  • Color: Black/White

Pins

PIN Description
VCC Power input(3.3V)
GND Ground
DIN MOSI pin of SPI (Data input)
CLK SCLK pin of SPI (Clock input)
CS Chip selection, low active
DC Data/Command, Low for command and High for data
RST Reset, Low active

Hardware Configuration

1.3inch OLED Module (C).png

The OLED module provides two drive interfaces: 4-wire SPI and I2C. There is a resistor that can be soldered on the back of the module, and the corresponding communication mode can be selected through the selection of the resistor, as shown in the figure:
The module uses 4-wire SPI communication mode by default, that is, IM is connected to 0 by default (1 and 0 do not represent the level, just the welding method of connecting or connecting the resistance, the specific hardware link is shown in the following table):
Note: The above picture is the welding on the hardware, the following table is the actual hardware connection

Communication Method IM
4-wire SPI 0
I2C 1

The specific hardware configuration is as follows:

  • Using 4-wire SPI:

That is, the factory program setting: IM is connected to 0 and connected to the ground;

  • Using I2C:

IM is connected to 1 to VCC (3.3V);
When using I2C: The high and low state of DC can control the address of the slave device. If it receives a low level, then the 7-bit address of I2C is: 0x3C;
PS: The program defaults to SPI mode. If you need to switch the mode, please modify DEV_Config.h. For details, please refer to the program description - bottom hardware interface - interface selection

OLED and its controller

This OLED integrates the SH1107 controller which has 128x128 bits SRAM, supports 128x128 resolution. The controller features SPI/IIC/ 6800/8080 interface and 256 brightness levels. The resolution of this 1.3inch OLED is only 64x128, only half of the SRAM is used.
This OLED use four-line SPI and I2C interface for communicating, which supports higher compatibility and speed.

Protocol

1.3inchOLED(C)-SPI.png
Note: The MISO pin is hidden, for more details, you can refer to Datasheet Page11.
CS: Chip selection of the slaver, the chip is activated when CS is Low;
SI(D1): This is MOSI pin, the pin is used to transmit data from master to slaver;
SCL(D0)is the SPI clock
A0: This is the DC pin, it is used to determine the data input, DC=0: command is sent;

SPI communication has data transfer timing, which is combined by CPHA and CPOL.
CPOL determines the level of the serial synchronous clock at an idle state. When CPOL = 0, the level is Low. However, CPOL has little effect on the transmission.
CPHA determines whether data is collected at the first clock edge or at the second clock edge of the serial synchronous clock; when CPHL = 0, data is collected at the first clock edge.
According to the figure, SCL is high in idle and it starts to transmit data at the second edge. therefore the timing is Mode 3 (0x11). Data is transmitted in MSB format.


RPi

We provide examples that are based on BCM2835、WiringPi、File IO and RPI(Python)librraies.

Hardware connection

You should connect the OLED to your Raspberry Pi by the 7pin cable according to the table

Connect to Raspberry Pi
OLED Raspberry Pi
BCM2835 Board
VCC 3.3V 3.3V
GND GND GND
DIN SPI:10 / IIC:2 SPI:MOSI / IIC:SDA.1
CLK SPI:11 / IIC:3 SPI:SCLK / IIC:SCL.1
CS 8 CE0
DC 25 GPIO.26
RST 27 GPIO.2
  • Four-wire SPI wiring diagram

1.3inch oled module c-spi.png

Enable SPI and IIC Interface

  • Open the Raspberry Pi terminal and run the following command
sudo raspi-config
Choose Interfacing Options -> SPI -> Yes 

Choose Interfacing Options -> I2C -> Yes RPI open spi.png
Reboot Raspberry Pi:

sudo reboot

Libraries Installation

  • Install BCM2835 libraries
wget http://www.airspayce.com/mikem/bcm2835/bcm2835-1.60.tar.gz
tar zxvf bcm2835-1.60.tar.gz 
cd bcm2835-1.60/
sudo ./configure
sudo make
sudo make check
sudo make install
#For more details, please refer to http://www.airspayce.com/mikem/bcm2835/
  • Install wiringPi libraries
sudo apt-get install wiringpi

#For Pi 4, you need to update it:
cd /tmp
wget https://project-downloads.drogon.net/wiringpi-latest.deb
sudo dpkg -i wiringpi-latest.deb
gpio -v
#You will get 2.52 information if you install it correctly
  • Install Python libraries
#python2
sudo apt-get update
sudo apt-get install python-pip
sudo apt-get install python-pil
sudo apt-get install python-numpy
sudo pip install RPi.GPIO
sudo pip install spidev
#python3
sudo apt-get update
sudo apt-get install python3-pip
sudo apt-get install python3-pil
sudo apt-get install python3-numpy
sudo pip3 install RPi.GPIO
sudo pip3 install spidev

Downlaod example

Open the terminal and run the following commands:

sudo apt-get install p7zip-full
sudo wget https://www.waveshare.com/w/upload/3/37/1.3inch_OLED_Module_C_code.7z
7z x 1.3inch_OLED_Module_C_code.7z -O./1.3inch_OLED_Module_C_code
cd 1.3inch_OLED_Module_C_code/raspberry/

Run the test codes

Please first go into the raspberry directory of examples and then run the following command:

C Code

  • Recompile may take a few seconds
cd c
sudo make clean
sudo make -j 8
  • The test program of all screens can be called directly by entering the corresponding size:
sudo ./main screen size
  • Depending on the LCD, you can enter one of the following commands:
#0.91inch OLED Module
sudo ./main 0.91
#0.95inch RGB OLED (A)/(B)
sudo ./main 0.95rgb
#0.96inch OLED (A)/(B)
sudo ./main 0.96
#1.3inch OLED (A)/(B)
sudo ./main 1.3
#1.3inch OLED Module (C)
sudo ./main 1.3c
#1.5inch OLED Module
sudo ./main 1.5
#1.5inch RGB OLED Module
sudo ./main 1.5rgb

Python

  • Enter the python program directory
cd python/example
  • Run the corresponding OLED demo, the program supports python2/3

If you purchased a 1.3inch OLED Module (C), please enter:

# python2
sudo python OLED_1in3_c_test.py
# python3
sudo python3 OLED_1in3_c_test.py

If you purchased a 1.5inch RGB OLED Module, please enter:

# python2
sudo python OLED_1in5_rgb_test.py
# python3
sudo python3 OLED_1in5_rgb_test.py
  • Model Command Correspondence Table
#0.91inch OLED Module
sudo python OLED_0in91_test.py
#0.95inch RGB OLED (A)/(B)
sudo python OLED_0in95_rgb_test.py
#0.96inch OLED (A)/(B)
sudo python OLED_0in96_test.py
#1.3inch OLED (A)/(B)
sudo python OLED_1in3_c_test.py
#1.3inch OLED Module (C)
sudo python OLED_1in3_test.py
#1.5inch OLED Module
sudo python OLED_1in5_test.py
#1.5inch RGB OLED Module
sudo python OLED_1in5_rgb_test.py
  • Please make sure the SPI is not occupied by other devices, you can check in the middle of /boot/config.txt

C

Hardware interface

1.There are three ways for C to drive:BCM2835 library, WiringPi library and Dev library respectively
2.We use Dev libraries by default. If you need to change to BCM2835 or WiringPi libraries ,please open RaspberryPi\c\Makefile and modify lines 13-15 as follows:
RPI open spi1.png
We have carried out the underlying encapsulation. Because the hardware platform is different, the internal implementation is different. If you need to know the internal implementation, you can go to the corresponding directory to view
You can see many definitions in DEV_Config.c(.h), in the directory: RaspberryPi\c\lib\Config

  • Interface selection:
#define USE_SPI_4W  1
#define USE_IIC     0
Note:Modified here directly to switch SPI/I2C.
  • Data type
#define UBYTE      uint8_t
#define UWORD      uint16_t
#define UDOUBLE    uint32_t
  • Module initialization and exit processing.
void DEV_Module_Init(void);
void DEV_Module_Exit(void);
Note: 
  Here is some GPIO processing before and after using the LCD screen.
  • Write GPIO.
void DEV_Digital_Write(UWORD Pin, UBYTE Value)
Parameter: 
     UWORD Pin: GPIO Pin number
     UBYTE Value: level to be output, 0 or 1
  • Read GPIO.
UBYTE DEV_Digital_Read(UWORD Pin)
Parameter:
     UWORD Pin:GPIO Pin number
     Return value: level of GPIO, 0 or 1
  • GPIO mode setting .
void DEV_GPIO_Mode(UWORD Pin, UWORD Mode)
Parameters: 
     UWORD Pin: GPIO Pin number
     UWORD Mode: Mode, 0: input, 1: output

GUI functions

If you need to draw pictures, display Chinese and English characters, display pictures, etc., we provide some basic functions here about some graphics processing in the directory RaspberryPi\c\lib\GUI\GUI_Paint.c(.h).
C-GUI.png
The fonts can be found in RaspberryPi\c\lib\Fonts directory.
RPI open spi3.png

  • New Image Properties: Create a new image buffer, this property includes the image buffer name, width, height, flip Angle, color.
void Paint_NewImage(UBYTE *image, UWORD Width, UWORD Height, UWORD Rotate, UWORD Color)
Parameters:
      Image: the name of the image buffer, which is actually a pointer to the first address of the image buffer;
      Width: image buffer Width;
      Height: the Height of the image buffer;
      Rotate: Indicates the rotation Angle of an image
      Color: the initial Color of the image;
  • Select image buffer: The purpose of the selection is that you can create multiple image attributes, there can be multiple images buffer, you can select each image you create.
void Paint_SelectImage(UBYTE *image)
Parameters:
       Image: the name of the image buffer, which is actually a pointer to the first address of the image buffer;
  • Image Rotation: Set the rotation Angle of the selected image, preferably after Paint_SelectImage(), you can choose to rotate 0, 90, 180, 270.
void Paint_SetRotate(UWORD Rotate)
Parameters:
        Rotate: ROTATE_0, ROTATE_90, ROTATE_180, and ROTATE_270 correspond to 0, 90, 180, and 270 degrees.
  • Sets the size of the pixels.
void Paint_SetScale(UBYTE scale)
Parameters:
	scale: the size of pixels, 2: each pixel occupies one bit; 4: Each pixel occupies two bits.
  • Image mirror flip: Set the mirror flip of the selected image. You can choose no mirror, horizontal mirror, vertical mirror, or image center mirror.
void Paint_SetMirroring(UBYTE mirror)
Parameters:
        Mirror: indicates the image mirroring mode. MIRROR_NONE, MIRROR_HORIZONTAL, MIRROR_VERTICAL, MIRROR_ORIGIN correspond to no mirror, horizontal mirror, vertical mirror, and image center mirror respectively.
  • Set points of the display position and color in the buffer: here is the core GUI function, processing points display position and color in the buffer.
void Paint_SetPixel(UWORD Xpoint, UWORD Ypoint, UWORD Color)
Parameters:
        Xpoint: the X position of a point in the image buffer
        Ypoint: Y position of a point in the image buffer
        Color: indicates the Color of the dot
  • Image buffer fill color: Fills the image buffer with a color, usually used to flash the screen into blank.
void Paint_Clear(UWORD Color)
Parameters:
        Color: fill Color
  • The fill color of a certain window in the image buffer: the image buffer part of the window filled with a certain color, usually used to fresh the screen into blank, often used for time display, fresh the last second of the screen.
void Paint_ClearWindows(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend, UWORD Color)
Parameters:
        Xstart: the x-starting coordinate of the window
        Ystart: the y-starting coordinate of the window
        Xend: the x-end coordinate of the window
        Yend: the y-end coordinate of the window
        Color: fill Color
  • Draw point: In the image buffer, draw points on (Xpoint, Ypoint), you can choose the color, the size of the point, the style of the point.
void Paint_DrawPoint(UWORD Xpoint, UWORD Ypoint, UWORD Color, DOT_PIXEL Dot_Pixel, DOT_STYLE Dot_Style)
Parameters:
        Xpoint: indicates the X coordinate of a point.
        Ypoint: indicates the Y coordinate of a point.
        Color: fill Color
        Dot_Pixel: The size of the dot, the demo provides 8 size pointss by default.
              typedef enum {
                 DOT_PIXEL_1X1  = 1,	// 1 x 1
                 DOT_PIXEL_2X2  , 		// 2 X 2
                 DOT_PIXEL_3X3  , 	 	// 3 X 3
                 DOT_PIXEL_4X4  , 	 	// 4 X 4
                 DOT_PIXEL_5X5  , 		// 5 X 5
                 DOT_PIXEL_6X6  , 		// 6 X 6
                 DOT_PIXEL_7X7  , 		// 7 X 7
                 DOT_PIXEL_8X8  , 		// 8 X 8
               } DOT_PIXEL;
        Dot_Style: the size of a point that expands from the center of the point or from the bottom left corner of the point to the right and up.
                 typedef enum {
                     DOT_FILL_AROUND  = 1,
                     DOT_FILL_RIGHTUP,
                  } DOT_STYLE;
  • Draw line: In the image buffer, draw line from (Xstart, Ystart) to (Xend, Yend), you can choose the color, the width and the style of the line.
void Paint_DrawLine(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend, UWORD Color, LINE_STYLE Line_Style ,  LINE_STYLE Line_Style)
Parameters:
        Xstart: the x-starting coordinate of a line
        Ystart: the y-starting coordinate of the a line
        Xend: the x-end coordinate of a line
        Yend: the y-end coordinate of a line
        Color: fill Color
        Line_width: The width of the line, the demo provides 8 sizes of width by default.
              typedef enum {
                 DOT_PIXEL_1X1  = 1,	// 1 x 1
                 DOT_PIXEL_2X2  , 		// 2 X 2
                 DOT_PIXEL_3X3  ,		// 3 X 3
                 DOT_PIXEL_4X4  ,		// 4 X 4
                 DOT_PIXEL_5X5  , 		// 5 X 5
                 DOT_PIXEL_6X6  , 		// 6 X 6
                 DOT_PIXEL_7X7  , 		// 7 X 7
                 DOT_PIXEL_8X8  , 		// 8 X 8
              } DOT_PIXEL;
        Line_Style: line style. Select whether the lines are joined in a straight or dashed way.
              typedef enum {
                 LINE_STYLE_SOLID = 0,
                 LINE_STYLE_DOTTED,
              } LINE_STYLE;
  • Draw rectangle: In the image buffer, draw a rectangle from (Xstart, Ystart) to (Xend, Yend), you can choose the color, the width of the line, whether to fill the inside of the rectangle.
void Paint_DrawRectangle(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend, UWORD Color, DOT_PIXEL Line_width,  DRAW_FILL Draw_Fill)
Parameters:
	Xstart: the starting X coordinate of the rectangle
	Ystart: the starting Y coordinate of the rectangle
	Xend: the x-end coordinate of the rectangle
        Yend: the y-end coordinate of the rectangle
	Color: fill Color
	Line_width: The width of the four sides of a rectangle. And the demo provides 8 sizes of width by default.
		typedef enum {
			DOT_PIXEL_1X1  = 1,	// 1 x 1
			DOT_PIXEL_2X2  , 		// 2 X 2
			DOT_PIXEL_3X3  ,		// 3 X 3
			DOT_PIXEL_4X4  ,	        // 4 X 4
			DOT_PIXEL_5X5  , 		// 5 X 5
 			DOT_PIXEL_6X6  , 		// 6 X 6
                        DOT_PIXEL_7X7  , 		// 7 X 7
                        DOT_PIXEL_8X8  , 		// 8 X 8
                 } DOT_PIXEL;
         Draw_Fill: Fill, whether to fill the inside of the rectangle
              typedef enum {
                 	DRAW_FILL_EMPTY = 0,
                 	DRAW_FILL_FULL,
              } DRAW_FILL;
  • Draw circle: In the image buffer, draw a circle of Radius with (X_Center Y_Center) as the center. You can choose the color, the width of the line, and whether to fill the inside of the circle.
void Paint_DrawCircle(UWORD X_Center, UWORD Y_Center, UWORD Radius, UWORD Color, DOT_PIXEL Line_width,  DRAW_FILL Draw_Fill)
Parameters:
	X_Center: the x-coordinate of the center of the circle
	Y_Center: the y-coordinate of the center of the circle
	Radius: indicates the Radius of a circle
	Color: fill Color
	Line_width: The width of the arc, with a default of 8 widths
		typedef enum {
        		DOT_PIXEL_1X1  = 1,	// 1 x 1
        		DOT_PIXEL_2X2  , 		// 2 X 2
        		DOT_PIXEL_3X3  ,		// 3 X 3
        		DOT_PIXEL_4X4  ,		// 4 X 4
        		DOT_PIXEL_5X5  , 		// 5 X 5
        		DOT_PIXEL_6X6  , 		// 6 X 6
        		DOT_PIXEL_7X7  , 		// 7 X 7
        		DOT_PIXEL_8X8  , 		// 8 X 8
		} DOT_PIXEL;
	Draw_Fill: fill, whether to fill the inside of the circle
              typedef enum {
              		DRAW_FILL_EMPTY = 0,
                 	DRAW_FILL_FULL,
              } DRAW_FILL;
  • Write Ascii character: In the image buffer, use (Xstart Ystart) as the left vertex, write an Ascii character, you can select Ascii visual character library, font foreground color, font background color.
void Paint_DrawChar(UWORD Xstart, UWORD Ystart, const char Ascii_Char, sFONT* Font, UWORD Color_Foreground,  UWORD Color_Background)
Parameters:
	Xstart: the x-coordinate of the left vertex of a character
	Ystart: the Y-coordinate of the left vertex of a character
	Ascii_Char: indicates the Ascii character
	Font: Ascii visual character library, in the Fonts folder the demo provides the following Fonts:
  		Font8: 5*8 font
    		Font12: 7*12 font
    		Font16: 11*16 font
    		Font20: 14*20 font
    		Font24: 17*24 font
  	Color_Foreground: Font color
  	Color_Background: indicates the background color
  • Write English string: In the image buffer, use (Xstart Ystart) as the left vertex, write a string of English characters, you can choose Ascii visual character library, font foreground color, font background color.
void Paint_DrawString_EN(UWORD Xstart, UWORD Ystart, const char * pString, sFONT* Font, UWORD Color_Foreground,  UWORD Color_Background)
Parameters:
	Xstart: the x-coordinate of the left vertex of a character
	Ystart: the Y coordinate of the font's left vertex
	PString: string, string is a pointer
	Font: Ascii visual character library, in the Fonts folder the demo provides the following Fonts:
     		Font8: 5*8 font
     		Font12: 7*12 font
     		Font16: 11*16 font
     		Font20: 14*20 font
     		Font24: 17*24 font
	Color_Foreground: Font color
  	Color_Background: indicates the background color
  • Write Chinese string: in the image buffer, use (Xstart Ystart) as the left vertex, write a string of Chinese characters, you can choose character font, font foreground color, font background color of the GB2312 encoding
void Paint_DrawString_CN(UWORD Xstart, UWORD Ystart, const char * pString, cFONT* font, UWORD Color_Foreground,  UWORD Color_Background)
Parameters:
	Xstart: the x-coordinate of the left vertex of a character
	Ystart: the Y coordinate of the font's left vertex
	PString: string, string is a pointer
  	Font: GB2312 encoding character Font library, in the Fonts folder the demo provides the following Fonts:
     		Font12CN: ASCII font 11*21, Chinese font 16*21
     		Font24CN: ASCII font24 *41, Chinese font 32*41
	Color_Foreground: Font color
	Color_Background: indicates the background color
  • Write numbers: In the image buffer,use (Xstart Ystart) as the left vertex, write a string of numbers, you can choose Ascii visual character library, font foreground color, font background color.
void Paint_DrawNum(UWORD Xpoint, UWORD Ypoint, double Nummber, sFONT* Font, UWORD Digit, UWORD Color_Foreground,   UWORD Color_Background)
Parameters:
	Xpoint: the x-coordinate of the left vertex of a character
	Ypoint: the Y coordinate of the left vertex of the font
	Nummber: indicates the number displayed, which can be a decimal
	Digit: It's a decimal number
 	Font: Ascii visual character library, in the Fonts folder the demo provides the following Fonts:
   		Font8: 5*8 font
   		Font12: 7*12 font
   		Font16: 11*16 font
		Font20: 14*20 font
   		Font24: 17*24 font
	Color_Foreground: Font color
	Color_Background: indicates the background color
  • Display time: in the image buffer,use (Xstart Ystart) as the left vertex, display time,you can choose Ascii visual character font, font foreground color, font background color.;
void Paint_DrawTime(UWORD Xstart, UWORD Ystart, PAINT_TIME *pTime, sFONT* Font, UWORD Color_Background,  UWORD Color_Foreground)
Parameters:
	Xstart: the x-coordinate of the left vertex of a character
 	Ystart: the Y coordinate of the font's left vertex
	PTime: display time, A time structure is defined here, as long as the hours, minutes and seconds are passed to the parameters;
	Font: Ascii visual character library, in the Fonts folder the demo provides the following Fonts:
     		Font8: 5*8 font
     		Font12: 7*12 font
     		Font16: 11*16 font
     		Font20: 14*20 font
     		Font24: 17*24 font
  	Color_Foreground: Font color
  	Color_Background: indicates the background color

Python(for Raspberry Pi)

It is compatible with python2.7 and python3.
The calls of the python are less complex compared to C demo.

config.py

  • Select interface.
Device_SPI = 1
Device_I2C = 0
Note: Switch SPI/I2C modified here
  • Module initialization and exit processing.
def module_init()
def module_exit()
Note:
1. Here is some GPIO processing before and after using the LCD screen.
2. The module_init() function is automatically called in the INIT () initializer on the LCD, but the module_exit() function needs to be called by itself
  • SPI write data.
def spi_writebyte(data)
  • IIC write data.
i2c_writebyte(reg, value):

main.py

The main function, if your Python version is Python2, is re-executed in Linux command mode as follows.

sudo python main.py

If your Python version is Python3, run the following command in Linux.

sudo python3 main.py

GUI functions

Python has an image library PIL official library link, it do not need to write code from the logical layer like C, can directly call to the image library for image processing. The following will take 1.54inch LCD as an example, we provide a brief description for the demo.

  • It needs to use the image library and install the library.
sudo apt-get install python3-pil  

And then import the library

from PIL import Image,ImageDraw,ImageFont.

Among them, Image is the basic library, ImageDraw is the drawing function, and ImageFont is the text function.

  • Define an image buffer
image1 = Image.new("1", (disp.width, disp.height), "WHITE")

The first parameter defines the color depth of the image, which is defined as "1" to indicate the bitmap of one-bit depth. The second parameter is a tuple that defines the width and height of the image. The third parameter defines the default color of the buffer, which is defined as "WHITE".

  • Create a drawing object based on Image1 on which all drawing operations will be performed on here.
draw = ImageDraw.Draw(image1)
  • Draw line.
draw.line([(0,0),(127,0)], fill = 0)

The first parameter is a four-element tuple starting at (0, 0) and ending at (127,0). Draw a line. Fill ="0" means the color of the line is white.

  • Draw rectangle.
draw.rectangle([(20,10),(70,60)],fill = "WHITE",outline="BLACK")

The first argument is a tuple of four elements. (20,10) is the coordinate value in the upper left corner of the rectangle, and (70,60) is the coordinate value in the lower right corner of the rectangle. Fill =" WHITE" means BLACK inside, and outline="BLACK" means the color of the outline is black.

  • Draw circle.
draw.arc((150,15,190,55),0, 360, fill =(0,255,0)

Draw an inscribed circle in the square, the first parameter is a tuple of 4 elements, with (150, 15) as the upper left corner vertex of the square, (190, 55) as the lower right corner vertex of the square, specifying the level median line of the rectangular frame is the angle of 0 degrees, the second parameter indicates the starting angle, the third parameter indicates the ending angle, and fill = 0 indicates that the the color of the line is white. If the figure is not square according to the coordination, you will get an ellipse.

Besides the arc function, you can also use the chord function for drawing solid circle.

draw.ellipse((150,65,190,105), fill = 0)

The first parameter is the coordination of the enclosing rectangle. The second and third parameters are the beginning and end degrees of the circle. The fourth parameter is the fill color of the circle.

  • Character.

The ImageFont module needs to be imported and instantiated:

Font1 = ImageFont.truetype("../Font/Font01.ttf",25)
Font2 = ImageFont.truetype("../Font/Font01.ttf",35)
Font3 = ImageFont.truetype("../Font/Font02.ttf",32)

You can use the fonts of Windows or other fonts which is in ttc format..
Note: Each character library contains different characters; If some characters cannot be displayed, it is recommended that you can refer to the encoding set ro used. To draw English character, you can directly use the fonts; for Chinese character, you need to add a symbol u:

draw.text((5, 68), 'Hello world', fill = 0, font=Font1)
text= u"微雪电子"
draw.text((5, 200), text, fill = 0, font=Font3)

The first parameter is a two-element tuple with (5,68) as the left vertex, and use font1, fill is font color, fill = 0 means that the font color is white, and the second sentence shows’微雪电子’, font color is white.

  • Read local picture.
image = Image.open('../pic/pic.bmp')

The parameter is the image path.

  • Other functions.

For more information, you can search online.

STM32 guides

The examples is based on STM32F103RBT6

Harware connection

The examples is based on STM32F103RBT6, if you want to use the OLED with other STM32 board, you should porting the codes to your project.

Connect to STM32F103RBT6
OLED STM32
VCC 3.3V
GND GND
DIN SPI:PA7 / IIC:PB9
CLK SPI:PA5 / IIC:PB8
CS PB6
DC PA8
RST PA9

Run demo codes

The examples provided are based on HAL libraries. Download the demo codes and go into STM32 directory
STM32 1 1in3OLED module c.png
Open the oled_demo.uvprojx project by Keil5, which is located in 1.3inch_OLED_Module(C)_code\STM32\MDK-ARM, compile and download it to your STM32 board


Arduino guides

Hardware connection

The examples and connections are based on Arduino UNO, if you want to use the OLED with other type of Arduino, you need to correct the connection and codes according to the Arduino board.

Connect to Arduino UNO
OLED UNO
VCC 3.3V
GND GND
DIN SPI:11 / IIC:SDA
CLK SPI:13 / IIC:SCL
CS D10
DC D7
RST D8

Run the example

Download the demo codes and go into Arduino directory.
Open the OLED_Show.ino file by Arduino IDE, which is located in 1.3inch_OLED_Module(C)_code\Arduino\OLED_Show, compile and upload the codes to your Arduino board


Resources

Documents

Demo codes


Support

If you require technical support, please go to the Support page and open a ticket.