ssd1306.h File Reference

#include <stddef.h>
#include <_ansi.h>
#include "ssd1306_conf.h"
#include "stm32f1xx_hal.h"
#include "ssd1306_fonts.h"

Go to the source code of this file.

Data Structures
struct	SSD1306_t
struct	SSD1306_VERTEX

Macros
#define	SSD1306_SPI_PORT   hspi2
#define	SSD1306_CS_Port   GPIOB
#define	SSD1306_CS_Pin   GPIO_PIN_12
#define	SSD1306_DC_Port   GPIOB
#define	SSD1306_DC_Pin   GPIO_PIN_14
#define	SSD1306_Reset_Port   GPIOA
#define	SSD1306_Reset_Pin   GPIO_PIN_8
#define	SSD1306_HEIGHT   64
#define	SSD1306_BUFFER_SIZE   SSD1306_WIDTH * SSD1306_HEIGHT / 8

Enumerations
enum	SSD1306_COLOR { Black = 0x00, White = 0x01 }
enum	SSD1306_Error_t { SSD1306_OK = 0x00, SSD1306_ERR = 0x01 }

Functions
void	ssd1306_SelectDisplay (uint8_t display)
void	ssd1306_Init (void)
void	ssd1306_Fill (SSD1306_COLOR color)
void	ssd1306_UpdateScreen (void)
void	ssd1306_DrawPixel (uint8_t x, uint8_t y, SSD1306_COLOR color)
char	ssd1306_WriteChar (char ch, FontDef Font, SSD1306_COLOR color)
char	ssd1306_WriteString (char *str, FontDef Font, SSD1306_COLOR color)
void	ssd1306_SetCursor (uint8_t x, uint8_t y)
void	ssd1306_Line (uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, SSD1306_COLOR color)
void	ssd1306_DrawArc (uint8_t x, uint8_t y, uint8_t radius, uint16_t start_angle, uint16_t sweep, SSD1306_COLOR color)
void	ssd1306_DrawCircle (uint8_t par_x, uint8_t par_y, uint8_t par_r, SSD1306_COLOR color)
void	ssd1306_Polyline (const SSD1306_VERTEX *par_vertex, uint16_t par_size, SSD1306_COLOR color)
void	ssd1306_DrawRectangle (uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, SSD1306_COLOR color)
void	ssd1306_SetContrast (const uint8_t value)
	Sets the contrast of the display. More...
void	ssd1306_SetDisplayOn (const uint8_t on)
	Set Display ON/OFF. More...
uint8_t	ssd1306_GetDisplayOn ()
	Reads DisplayOn state. More...
void	ssd1306_Reset (void)
void	ssd1306_WriteCommand (uint8_t byte)
void	ssd1306_WriteData (uint8_t *buffer, size_t buff_size)
SSD1306_Error_t	ssd1306_FillBuffer (uint8_t *buf, uint32_t len)

Variables
I2C_HandleTypeDef	hi2c1

Macro Definition Documentation

SSD1306_BUFFER_SIZE

#define SSD1306_BUFFER_SIZE   SSD1306_WIDTH * SSD1306_HEIGHT / 8

Definition at line 101 of file ssd1306.h.

SSD1306_CS_Pin

#define SSD1306_CS_Pin   GPIO_PIN_12

Definition at line 63 of file ssd1306.h.

SSD1306_CS_Port

#define SSD1306_CS_Port   GPIOB

Definition at line 60 of file ssd1306.h.

SSD1306_DC_Pin

#define SSD1306_DC_Pin   GPIO_PIN_14

Definition at line 70 of file ssd1306.h.

SSD1306_DC_Port

#define SSD1306_DC_Port   GPIOB

Definition at line 67 of file ssd1306.h.

SSD1306_HEIGHT

#define SSD1306_HEIGHT   64

Definition at line 92 of file ssd1306.h.

SSD1306_Reset_Pin

#define SSD1306_Reset_Pin   GPIO_PIN_8

Definition at line 77 of file ssd1306.h.

SSD1306_Reset_Port

#define SSD1306_Reset_Port   GPIOA

Definition at line 74 of file ssd1306.h.

SSD1306_SPI_PORT

#define SSD1306_SPI_PORT   hspi2

This Library was originally written by Olivier Van den Eede (4ilo) in 2016. Some refactoring was done and SPI support was added by Aleksander Alekseev (afiskon) in 2018.

https://github.com/afiskon/stm32-ssd1306

Definition at line 56 of file ssd1306.h.

Enumeration Type Documentation

SSD1306_COLOR

enum SSD1306_COLOR

Enumerator
Black
White

Definition at line 105 of file ssd1306.h.

             {
    Black = 0x00, /* Black color, no pixel */
    White = 0x01  /* Pixel is set. Color depends on OLED */
} SSD1306_COLOR;

SSD1306_Error_t

enum SSD1306_Error_t

Enumerator
SSD1306_OK
SSD1306_ERR

Definition at line 110 of file ssd1306.h.

             {
    SSD1306_OK = 0x00,
    SSD1306_ERR = 0x01  /* Generic error. */
} SSD1306_Error_t;

Function Documentation

ssd1306_DrawArc()

void ssd1306_DrawArc	(	uint8_t	x,
		uint8_t	y,
		uint8_t	radius,
		uint16_t	start_angle,
		uint16_t	sweep,
		SSD1306_COLOR	color
	)

Definition at line 429 of file ssd1306.c.

                                                                                                                      {
    #define CIRCLE_APPROXIMATION_SEGMENTS 36
    float approx_degree;
    uint32_t approx_segments;
    uint8_t xp1;
    uint8_t xp2;
    uint8_t yp1;
    uint8_t yp2;
    uint32_t count = 0;
    uint32_t loc_sweep = 0;
    float rad;
    
    loc_sweep = ssd1306_NormalizeTo0_360(sweep);
    
    count = (ssd1306_NormalizeTo0_360(start_angle) * CIRCLE_APPROXIMATION_SEGMENTS) / 360;
    approx_segments = (loc_sweep * CIRCLE_APPROXIMATION_SEGMENTS) / 360;
    approx_degree = loc_sweep / (float)approx_segments;
    while(count < approx_segments)
    {
        rad = ssd1306_DegToRad(count*approx_degree);
        xp1 = x + (int8_t)(sin(rad)*radius);
        yp1 = y + (int8_t)(cos(rad)*radius);    
        count++;
        if(count != approx_segments)
        {
            rad = ssd1306_DegToRad(count*approx_degree);
        }
        else
        {            
            rad = ssd1306_DegToRad(loc_sweep);
        }
        xp2 = x + (int8_t)(sin(rad)*radius);
        yp2 = y + (int8_t)(cos(rad)*radius);    
        ssd1306_Line(xp1,yp1,xp2,yp2,color);
    }
    
    return;
}

ssd1306_DrawCircle()

void ssd1306_DrawCircle	(	uint8_t	par_x,
		uint8_t	par_y,
		uint8_t	par_r,
		SSD1306_COLOR	color
	)

Definition at line 468 of file ssd1306.c.

                                                                                           {
  int32_t x = -par_r;
  int32_t y = 0;
  int32_t err = 2 - 2 * par_r;
  int32_t e2;
 
  if (par_x >= SSD1306_WIDTH || par_y >= SSD1306_HEIGHT) {
    return;
  }
 
    do {
      ssd1306_DrawPixel(par_x - x, par_y + y, par_color);
      ssd1306_DrawPixel(par_x + x, par_y + y, par_color);
      ssd1306_DrawPixel(par_x + x, par_y - y, par_color);
      ssd1306_DrawPixel(par_x - x, par_y - y, par_color);
        e2 = err;
        if (e2 <= y) {
            y++;
            err = err + (y * 2 + 1);
            if(-x == y && e2 <= x) {
              e2 = 0;
            }
            else
            {
              /* nothing to do */
            }
        }
        else
        {
          /* nothing to do */
        }
        if(e2 > x) {
          x++;
          err = err + (x * 2 + 1);
        }
        else
        {
          /* nothing to do */
        }
    } while(x <= 0);
 
    return;
}

ssd1306_DrawPixel()

void ssd1306_DrawPixel	(	uint8_t	x,
		uint8_t	y,
		SSD1306_COLOR	color
	)

Definition at line 239 of file ssd1306.c.

                                                                  {
    if(x >= SSD1306_WIDTH || y >= SSD1306_HEIGHT) {
        /* Don't write outside the buffer */
        return;
    }
    
    /* Check if pixel should be inverted */
    if (ssd1306Display == 0)
    {
        if(SSD1306Left.Inverted) {
            color = (SSD1306_COLOR)!color;
        }
    }
    else if (ssd1306Display == 1)
    {
        if(SSD1306Right.Inverted) {
            color = (SSD1306_COLOR)!color;
        }
    }
 
    
    /* Draw in the right color */
    if(color == White) {
        if (ssd1306Display == 0) SSD1306_BufferLeft[x + (y / 8) * SSD1306_WIDTH] |= 1 << (y % 8);
        else if (ssd1306Display == 1) SSD1306_BufferRight[x + (y / 8) * SSD1306_WIDTH] |= 1 << (y % 8);
    } else { 
        if (ssd1306Display == 0) SSD1306_BufferLeft[x + (y / 8) * SSD1306_WIDTH] &= ~(1 << (y % 8));
        else if (ssd1306Display == 1) SSD1306_BufferRight[x + (y / 8) * SSD1306_WIDTH] &= ~(1 << (y % 8));
    }
}

ssd1306_DrawRectangle()

void ssd1306_DrawRectangle	(	uint8_t	x1,
		uint8_t	y1,
		uint8_t	x2,
		uint8_t	y2,
		SSD1306_COLOR	color
	)

Definition at line 513 of file ssd1306.c.

                                                                                                {
  ssd1306_Line(x1,y1,x2,y1,color);
  ssd1306_Line(x2,y1,x2,y2,color);
  ssd1306_Line(x2,y2,x1,y2,color);
  ssd1306_Line(x1,y2,x1,y1,color);
 
  return;
}

ssd1306_Fill()

void ssd1306_Fill

(

SSD1306_COLOR

color

)

Definition at line 199 of file ssd1306.c.

                                       {
    /* Set memory */
    uint32_t i;
 
    if (ssd1306Display == 0)
    {
        for(i = 0; i < sizeof(SSD1306_BufferLeft); i++) {
            SSD1306_BufferLeft[i] = (color == Black) ? 0x00 : 0xFF;
        }
    }
    else if (ssd1306Display == 1)
    {
        for(i = 0; i < sizeof(SSD1306_BufferRight); i++) {
            SSD1306_BufferRight[i] = (color == Black) ? 0x00 : 0xFF;
        }
    }
 
 
}

ssd1306_FillBuffer()

SSD1306_Error_t ssd1306_FillBuffer	(	uint8_t *	buf,
		uint32_t	len
	)

Definition at line 83 of file ssd1306.c.

                                                               {
    SSD1306_Error_t ret = SSD1306_ERR;
    if (len <= SSD1306_BUFFER_SIZE) {
        if (ssd1306Display == 0) memcpy(SSD1306_BufferLeft,buf,len);
        else if (ssd1306Display == 1) memcpy(SSD1306_BufferRight,buf,len);
        ret = SSD1306_OK;
    }
    return (ret);
}

ssd1306_GetDisplayOn()

uint8_t ssd1306_GetDisplayOn

(

)

Reads DisplayOn state.

Returns

0: OFF. 1: ON.

Definition at line 542 of file ssd1306.c.

                               {
    if (ssd1306Display == 0) return (SSD1306Left.DisplayOn);
    else if (ssd1306Display == 1) return (SSD1306Right.DisplayOn);
    return (0);
}

ssd1306_Init()

void ssd1306_Init

(

void

)

Definition at line 94 of file ssd1306.c.

                        {
    /* Reset OLED */
    ssd1306_Reset();
 
    /* Wait for the screen to boot */
    LL_mDelay(100);
 
    /* Init OLED */
    ssd1306_SetDisplayOn(0); /* display off */
 
    ssd1306_WriteCommand(0x20); /* Set Memory Addressing Mode */
    ssd1306_WriteCommand(0x00); /* 00b,Horizontal Addressing Mode; 01b,Vertical Addressing Mode;  */
                                /* 10b,Page Addressing Mode (RESET); 11b,Invalid  */
 
    ssd1306_WriteCommand(0xB0); /*Set Page Start Address for Page Addressing Mode,0-7  */
 
#ifdef SSD1306_MIRROR_VERT
    ssd1306_WriteCommand(0xC0); /* Mirror vertically */
#else
    ssd1306_WriteCommand(0xC8); /* Set COM Output Scan Direction */
#endif
 
    ssd1306_WriteCommand(0x00); /* ---set low column address */
    ssd1306_WriteCommand(0x10); /* ---set high column address */
 
    ssd1306_WriteCommand(0x40); /* --set start line address - CHECK */
 
    ssd1306_SetContrast(0xFF);
 
#ifdef SSD1306_MIRROR_HORIZ
    ssd1306_WriteCommand(0xA0); /* Mirror horizontally  */
#else
    ssd1306_WriteCommand(0xA1); /* --set segment re-map 0 to 127 - CHECK */
#endif
 
#ifdef SSD1306_INVERSE_COLOR
    ssd1306_WriteCommand(0xA7); /* --set inverse color */
#else
    ssd1306_WriteCommand(0xA6); /* --set normal color */
#endif
 
/* Set multiplex ratio. */
#if (SSD1306_HEIGHT == 128)
    /* Found in the Luma Python lib for SH1106. */
    ssd1306_WriteCommand(0xFF);
#else
    ssd1306_WriteCommand(0xA8); /* --set multiplex ratio(1 to 64) - CHECK */
#endif
 
#if (SSD1306_HEIGHT == 32)
    ssd1306_WriteCommand(0x1F);
#elif (SSD1306_HEIGHT == 64)
    ssd1306_WriteCommand(0x3F);
#elif (SSD1306_HEIGHT == 128)
    ssd1306_WriteCommand(0x3F); /* Seems to work for 128px high displays too. */
#else
#error "Only 32, 64, or 128 lines of height are supported!"
#endif
 
    ssd1306_WriteCommand(0xA4); /* 0xa4,Output follows RAM content;0xa5,Output ignores RAM content */
 
    ssd1306_WriteCommand(0xD3); /* -set display offset - CHECK */
    ssd1306_WriteCommand(0x00); /* -not offset */
 
    ssd1306_WriteCommand(0xD5); /* --set display clock divide ratio/oscillator frequency */
    ssd1306_WriteCommand(0xF0); /* --set divide ratio */
 
    ssd1306_WriteCommand(0xD9); /* --set pre-charge period */
    ssd1306_WriteCommand(0x22);
 
    ssd1306_WriteCommand(0xDA); /* --set com pins hardware configuration - CHECK */
#if (SSD1306_HEIGHT == 32)
    ssd1306_WriteCommand(0x02);
#elif (SSD1306_HEIGHT == 64)
    ssd1306_WriteCommand(0x12);
#elif (SSD1306_HEIGHT == 128)
    ssd1306_WriteCommand(0x12);
#else
#error "Only 32, 64, or 128 lines of height are supported!"
#endif
 
    ssd1306_WriteCommand(0xDB); /* --set vcomh */
    ssd1306_WriteCommand(0x20); /* 0x20,0.77xVcc */
 
    ssd1306_WriteCommand(0x8D); /* --set DC-DC enable */
    ssd1306_WriteCommand(0x14);
    ssd1306_SetDisplayOn(1); /* --turn on SSD1306 panel */
 
    /* Clear screen */
    ssd1306_Fill(Black);
    
    /* Flush buffer to screen */
    ssd1306_UpdateScreen();
    
    /* Set default values for screen object */
    if (ssd1306Display == 0) SSD1306Left.CurrentX = 0;
    else if (ssd1306Display == 1) SSD1306Right.CurrentX = 0;
    if (ssd1306Display == 0) SSD1306Left.CurrentY = 0;
    else if (ssd1306Display == 1) SSD1306Right.CurrentY = 0;
    
    if (ssd1306Display == 0) SSD1306Left.Initialized = 1;
    else if (ssd1306Display == 1) SSD1306Right.Initialized = 1;
}

ssd1306_Line()

void ssd1306_Line	(	uint8_t	x1,
		uint8_t	y1,
		uint8_t	x2,
		uint8_t	y2,
		SSD1306_COLOR	color
	)

Definition at line 358 of file ssd1306.c.

                                                                                       {
  int32_t deltaX = abs(x2 - x1);
  int32_t deltaY = abs(y2 - y1);
  int32_t signX = ((x1 < x2) ? 1 : -1);
  int32_t signY = ((y1 < y2) ? 1 : -1);
  int32_t error = deltaX - deltaY;
  int32_t error2;
    
  ssd1306_DrawPixel(x2, y2, color);
    while((x1 != x2) || (y1 != y2))
    {
    ssd1306_DrawPixel(x1, y1, color);
    error2 = error * 2;
    if(error2 > -deltaY)
    {
        error -= deltaY;
        x1 += signX;
    }
    else
    {
        /* nothing to do */
    }
        
    if(error2 < deltaX)
    {
        error += deltaX;
        y1 += signY;
    }
    else
    {
        /* nothing to do */
    }
  }
  return;
}

ssd1306_Polyline()

void ssd1306_Polyline	(	const SSD1306_VERTEX *	par_vertex,
		uint16_t	par_size,
		SSD1306_COLOR	color
	)

Definition at line 394 of file ssd1306.c.

                                                                                                {
  uint16_t i;
  if(par_vertex != 0){
    for(i = 1; i < par_size; i++){
      ssd1306_Line(par_vertex[i - 1].x, par_vertex[i - 1].y, par_vertex[i].x, par_vertex[i].y, color);
    }
  }
  else
  {
    /* nothing to do */
  }
  return;
}

ssd1306_Reset()

void ssd1306_Reset

(

void

)

Definition at line 15 of file ssd1306.c.

                         {
    /* For I2C - do nothing */
}

ssd1306_SelectDisplay()

void ssd1306_SelectDisplay

(

uint8_t

display

)

Definition at line 19 of file ssd1306.c.

{
    ssd1306Display = display;
 
    /* Left display selected */
    if (display == 0) ssd1306Address = 0x78;
 
    /* Right display selected */
    if (display == 1) ssd1306Address = 0x7A;
}

ssd1306_SetContrast()

void ssd1306_SetContrast

(

const uint8_t

value

)

Sets the contrast of the display.

Parameters

[in]

value

contrast to set.

Note

Contrast increases as the value increases.

RESET = 7Fh.

Definition at line 522 of file ssd1306.c.

                                              {
    const uint8_t kSetContrastControlRegister = 0x81;
    ssd1306_WriteCommand(kSetContrastControlRegister);
    ssd1306_WriteCommand(value);
}

ssd1306_SetCursor()

void ssd1306_SetCursor	(	uint8_t	x,
		uint8_t	y
	)

Definition at line 344 of file ssd1306.c.

                                             {
    if (ssd1306Display == 0)
    {
        SSD1306Left.CurrentX = x;
        SSD1306Left.CurrentY = y;
    }
    else if (ssd1306Display == 1)
    {
        SSD1306Right.CurrentX = x;
        SSD1306Right.CurrentY = y;
    }
}

ssd1306_SetDisplayOn()

void ssd1306_SetDisplayOn

(

const uint8_t

on

)

Set Display ON/OFF.

Parameters

[in]

on

0 for OFF, any for ON.

Definition at line 528 of file ssd1306.c.

                                            {
    uint8_t value;
    if (on) {
        value = 0xAF;   /* Display on */
        if (ssd1306Display == 0) SSD1306Left.DisplayOn = 1;
        else if (ssd1306Display == 1) SSD1306Right.DisplayOn = 1;
    } else {
        value = 0xAE;   /* Display off */
        if (ssd1306Display == 0) SSD1306Left.DisplayOn = 0;
        else if (ssd1306Display == 1) SSD1306Right.DisplayOn = 0;
    }
    ssd1306_WriteCommand(value);
}

ssd1306_UpdateScreen()

void ssd1306_UpdateScreen

(

void

)

Definition at line 220 of file ssd1306.c.

                                {
    /* Write data to each page of RAM. Number of pages
     *  depends on the screen height:
     *   - 32px   ==  4 pages
     *   - 64px   ==  8 pages
     *   - 128px  ==  16 pages */
    for(uint8_t i = 0; i < SSD1306_HEIGHT/8; i++) {
        ssd1306_WriteCommand(0xB0 + i); /* Set the current RAM page address. */
        ssd1306_WriteCommand(0x00);
        ssd1306_WriteCommand(0x10);
        if (ssd1306Display == 0) ssd1306_WriteData(&SSD1306_BufferLeft[SSD1306_WIDTH*i],SSD1306_WIDTH);
        if (ssd1306Display == 1) ssd1306_WriteData(&SSD1306_BufferRight[SSD1306_WIDTH*i],SSD1306_WIDTH);
    }
}

ssd1306_WriteChar()

char ssd1306_WriteChar	(	char	ch,
		FontDef	Font,
		SSD1306_COLOR	color
	)

Definition at line 274 of file ssd1306.c.

                                                                   {
    uint32_t i;
    uint32_t b;
    uint32_t j;
    
    /* Check if character is valid */
    if (ch < 32 || ch > 126)
        return (0);
    
    /* Check remaining space on current line */
    if (ssd1306Display == 0)
    {
        if (SSD1306_WIDTH < (SSD1306Left.CurrentX + Font.FontWidth) ||
            SSD1306_HEIGHT < (SSD1306Left.CurrentY + Font.FontHeight))
        {
            /* Not enough space on current line */
            return (0);
        }
    }
    else if (ssd1306Display == 1)
    {
        if (SSD1306_WIDTH < (SSD1306Right.CurrentX + Font.FontWidth) ||
            SSD1306_HEIGHT < (SSD1306Right.CurrentY + Font.FontHeight))
        {
            /* Not enough space on current line */
            return (0);
        }
    }
    
 
    /* Use the font to write */
    for(i = 0; i < Font.FontHeight; i++) {
        b = Font.data[(ch - 32) * Font.FontHeight + i];
        for(j = 0; j < Font.FontWidth; j++) {
            if((b << j) & 0x8000)  {
                if (ssd1306Display == 0) ssd1306_DrawPixel(SSD1306Left.CurrentX + j, (SSD1306Left.CurrentY + i), (SSD1306_COLOR) color);
                else if (ssd1306Display == 1) ssd1306_DrawPixel(SSD1306Right.CurrentX + j, (SSD1306Right.CurrentY + i), (SSD1306_COLOR) color);
            } else {
                if (ssd1306Display == 0) ssd1306_DrawPixel(SSD1306Left.CurrentX + j, (SSD1306Left.CurrentY + i), (SSD1306_COLOR)!color);
                else if (ssd1306Display == 1) ssd1306_DrawPixel(SSD1306Right.CurrentX + j, (SSD1306Right.CurrentY + i), (SSD1306_COLOR)!color);
            }
        }
    }
    
    /* The current space is now taken */
    if (ssd1306Display == 0) SSD1306Left.CurrentX += Font.FontWidth;
    else if (ssd1306Display == 1) SSD1306Right.CurrentX += Font.FontWidth;
    
    /* Return written char for validation */
    return (ch);
}

ssd1306_WriteCommand()

void ssd1306_WriteCommand

(

uint8_t

byte

)

Definition at line 31 of file ssd1306.c.

                                        {
    HAL_I2C_Mem_Write(&SSD1306_I2C_PORT, ssd1306Address, 0x00, 1, &byte, 1, HAL_MAX_DELAY);
}

ssd1306_WriteData()

void ssd1306_WriteData	(	uint8_t *	buffer,
		size_t	buff_size
	)

Definition at line 36 of file ssd1306.c.

                                                          {
    HAL_I2C_Mem_Write(&SSD1306_I2C_PORT, ssd1306Address, 0x40, 1, buffer, buff_size, HAL_MAX_DELAY);
}

ssd1306_WriteString()

char ssd1306_WriteString	(	char *	str,
		FontDef	Font,
		SSD1306_COLOR	color
	)

Definition at line 327 of file ssd1306.c.

                                                                       {
    /* Write until null-byte */
    while (*str) {
        if (ssd1306_WriteChar(*str, Font, color) != *str) {
            /* Char could not be written */
            return (*str);
        }
        
        /* Next char */
        str++;
    }
    
    /* Everything ok */
    return (*str);
}

Variable Documentation

hi2c1

I2C_HandleTypeDef hi2c1

Definition at line 27 of file i2c.c.