SSD1306 OLED 驱动

最新推荐文章于 2024-03-30 15:42:16 发布
置顶 最新推荐文章于 2024-03-30 15:42:16 发布
阅读量3.6w 收藏 23
点赞数 2
分类专栏： LCD 文章标签： oled SSD1306 驱动

前一阵子回家买了个 OLED （128 x 64，SSD1306）——Mini STM32 板的配件，这两天把驱动做完了，拿出来晾晾。


驱动是 pixel device 形式的。一开始本来打算做 frame buffer 形式的，但在测试时遇到了 hard fault 。俺怀疑是 RTGUI 的 frame buffer 驱动对单色显示的支持还不完善，但没有深究。
选用 pixel device 形式，也需要修改 RTGUI 代码以增加对单色显示的支持（”pixel_driver.c” and “color.h”）。
上图的 demo 使用新版 RTGUI，显示了一个 window，window 里有一个 label，没用 container。另外还显示了一张 bmp 图。图本身是单色的，加载时大小缩至 1/8。

和 LCD 对比一下， :) 。


再发点牢骚，新版 RTGUI 似乎在显示更新上有效率问题。比如上图的 demo ，有三个 window。按说每个 window 应该只绘制一次，但实际上似乎每个都绘制了三次。
现象：demo 中，背景的 main window 里面有个 container。在处理绘制 container 的 RTGUI_EVENT_PAINT 事件时，加载了一张图。最终，此图被加载了三次。
对于要加载大图的程序来说，这基本是噩梦。俺记得旧版没有这个问题。当然，有可能是俺对新版还不了解、使用不当。以后再研究吧。


更新：

跟 grissiom 兄在 github 上讨教了一下。感觉重复绘制问题是由于俺对新版 API 不了解所导致的。旧版有 workbench 、 view 的概念；新版没有，但多了  application 。使得有些功能在新版中得到了简化，还有些似乎是重新组织了一下。

俺的 demo （可在 RT-Thread EFM32 分支的代码中找到）在旧版中大概是这样的结构：

app --|--> workbench1 --> view1 --> (child) lable1  
      |--> workbench2 --> view2 (load image when painting) --> (child) lable2 
      |--> win_hello + box --> (child) lable3
当移植到新版时，俺根据一些例程和猜测，把 demo 改成了这个样子： 

app --|--> win_info --> (child) container1 --> (child) lable1 
      |--> win_main --> (child) container2 (load image when painting) --> (child) lable2 
      |--> win_hello + box --> (child) lable3
在和 grissiom 兄讨教之后，俺又改成了这样：
app --|--> win_info --> (child) lable1
      |--> win_main (load image when painting) --> (child) lable2
      |--> win_hello + box --> (child) lable3

现在就没有重复绘制的问题了。看来新版 API 确实在简化应用程序开发方面做了不少努力。但是控件分组的功能要咋实现呢？待俺以后再研究吧。
下面是代码：

drv_oled.c

/***************************************************************************//**
 * @file 	dev_oled.c
 * @brief 	OLED driver of RT-Thread RTOS for MiniSTM32
 * 	COPYRIGHT (C) 2012, RT-Thread Development Team
 * @author 	onelife
 * @version 1.0
 *******************************************************************************
 * @section License
 * The license and distribution terms for this file may be found in the file
 *  LICENSE in this distribution or at http://www.rt-thread.org/license/LICENSE
 *******************************************************************************
 * @section Change Logs
 * Date			Author		Notes
 * 2012-06-15	onelife		Initial creation for MiniSTM32
 ******************************************************************************/

/***************************************************************************//**
 * @addtogroup MiniSTM32
 * @{
 ******************************************************************************/

/* Includes ------------------------------------------------------------------*/
#include "board.h"
#include "drv_oled.h"

#if defined(MINISTM32_USING_OLED)
#include <rtgui/rtgui.h>
#include <rtgui/driver.h>

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
#ifdef MINISTM32_OLED_DEBUG
#define oled_debug(format,args...)      rt_kprintf(format, ##args)
#else
#define oled_debug(format,args...)
#endif

/* Private function prototypes -----------------------------------------------*/
static void oled_setPixel(rtgui_color_t *c, int x, int y);
static void oled_getPixel(rtgui_color_t *c, int x, int y);
static void oled_drawHLine(rtgui_color_t *c, int x1, int x2, int y);
static void oled_drawVLine(rtgui_color_t *c, int x , int y1, int y2);
static void oled_drawRawHLine(rt_uint8_t *pixels, int x1, int x2, int y);

/* Private variables ---------------------------------------------------------*/
static struct rt_device oled_device;
struct rt_semaphore oled_lock;
static struct rt_device_graphic_info oled_info;
//static rt_uint8_t frame_buffer[MINISTM32_OLED_HEIGHT/8][MINISTM32_OLED_WIDTH];
static const struct rtgui_graphic_driver_ops oled_ops =
    {
        oled_setPixel,
        oled_getPixel,
        oled_drawHLine,
        oled_drawVLine,
        oled_drawRawHLine
    };

/* Private functions ---------------------------------------------------------*/
rt_inline void oled_delayUs(rt_uint32_t us)
{
    /* This function is not that accurate */
    rt_uint32_t i = SystemCoreClock / 1000000 * us / 3;

    for(; i > 0; i--);
}

rt_inline void ssd1306_writeByte(rt_uint8_t data)
{
    MINISTM32_OLED_DATA_OUT(data);
    MINISTM32_OLED_WR_RESET;
    MINISTM32_OLED_WR_SET;
}

rt_inline void ssd1306_readByte(rt_uint8_t *data)
{
    GPIOB->CRL = 0x88888888;
    GPIOB->ODR = (GPIOB->ODR & 0x0000FF00) | 0x000000FF;

    MINISTM32_OLED_RD_RESET;
    MINISTM32_OLED_DATA_IN(data);
    MINISTM32_OLED_RD_SET;

	GPIOB->CRL = 0x33333333;
    GPIOB->ODR = (GPIOB->ODR & 0x0000FF00) | 0x000000FF;
}

rt_inline void ssd1306_readBuffer(rt_uint8_t *data, rt_uint8_t size)
{
    rt_uint8_t i;

    GPIOB->CRL = 0x88888888;
    GPIOB->ODR = (GPIOB->ODR & 0x0000FF00) | 0x000000FF;

    for (i = 0; i < size; i++)
    {
        MINISTM32_OLED_RD_RESET;
        MINISTM32_OLED_DATA_IN(data++);
        MINISTM32_OLED_RD_SET;
    }

	GPIOB->CRL = 0x33333333;
    GPIOB->ODR = (GPIOB->ODR & 0x0000FF00) | 0x000000FF;
}

static void oled_writeCmd(rt_uint8_t data)
{
    MINISTM32_OLED_CS_RESET;
    MINISTM32_OLED_DC_RESET;
    ssd1306_writeByte(data);
    MINISTM32_OLED_DC_SET;
    MINISTM32_OLED_CS_SET;
}

static void oled_writeLongCmd(rt_uint8_t *data, rt_uint8_t size)
{
    rt_uint8_t i;

    MINISTM32_OLED_CS_RESET;
    MINISTM32_OLED_DC_RESET;
    for (i = 0; i < size; i++)
    {
        ssd1306_writeByte(*data++);
    }
    MINISTM32_OLED_DC_SET;
    MINISTM32_OLED_CS_SET;
}

static void oled_writeData(rt_uint8_t *data, rt_uint8_t size)
{
    rt_uint8_t i;

    MINISTM32_OLED_CS_RESET;
    for (i = 0; i < size; i++)
    {
        ssd1306_writeByte(*data++);
    }
    MINISTM32_OLED_CS_SET;
}

static void oled_readStatus(rt_uint8_t *data)
{
    MINISTM32_OLED_CS_RESET;
    MINISTM32_OLED_DC_RESET;
    ssd1306_readByte(data);
    MINISTM32_OLED_DC_SET;
    MINISTM32_OLED_CS_SET;
}

static void oled_readData(rt_uint8_t *data, rt_uint8_t size)
{
    rt_uint8_t dummy;

    MINISTM32_OLED_CS_RESET;
    ssd1306_readByte(&dummy);
    ssd1306_readBuffer(data, size);
    MINISTM32_OLED_CS_SET;
}

void oled_clear(void)
{
	rt_uint32_t i;
    rt_uint8_t data[3];

    // Set column address
    data[0] = 0x21;
    data[1] = 0x00;
    data[2] = MINISTM32_OLED_WIDTH - 1;
    oled_writeLongCmd(data, 3);

    // Set page address
    data[0] = 0x22;
    data[1] = 0x00;
    data[2] = (MINISTM32_OLED_HEIGHT - 1) / 8;
    oled_writeLongCmd(data, 3);

    MINISTM32_OLED_CS_RESET;
	for (i = 0; i < (MINISTM32_OLED_WIDTH * (MINISTM32_OLED_HEIGHT / 8)); i++)
    {
        ssd1306_writeByte(0x00);
//        oled_delayUs(100);
	}
    MINISTM32_OLED_CS_SET;
}

static void ssd1306_gpio_init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    /* Config GPIO */
    RCC_APB2PeriphClockCmd(MINISTM32_OLED_DATA_CLOCK | \
        MINISTM32_OLED_CTRL_CLOCK | RCC_APB2Periph_AFIO, ENABLE);
    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Pin   = \
        GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | \
        GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
    GPIO_Init(MINISTM32_OLED_DATA_PORT, &GPIO_InitStructure);
    GPIO_Write(MINISTM32_OLED_DATA_PORT, GPIO_InitStructure.GPIO_Pin);

    GPIO_InitStructure.GPIO_Pin   = \
        MINISTM32_OLED_CS_PIN | MINISTM32_OLED_DC_PIN | \
        MINISTM32_OLED_WR_PIN | MINISTM32_OLED_RD_PIN;
    GPIO_Init(MINISTM32_OLED_CTRL_PORT, &GPIO_InitStructure);
    GPIO_Write(MINISTM32_OLED_CTRL_PORT, GPIO_InitStructure.GPIO_Pin);

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);
}

static rt_err_t ssd1306_init(void)
{
    rt_uint8_t data[2];

    ssd1306_gpio_init();

    // Turn off panel
    oled_writeCmd(0xAE);

    // Set display clock
    data[0] = 0xD5;
    data[1] = 0x80;         // default
    oled_writeLongCmd(data, 2);
    // Set charge pump
    data[0] = 0x8D;
    data[1] = 0x14;         // enable
    oled_writeLongCmd(data, 2);
    // Set pre-charge period
    data[0] = 0xD9;
    data[1] = 0xF1;
    oled_writeLongCmd(data, 2);
    // Set Vcomh deselect level
    data[0] = 0xDB;
    data[1] = 0x30;         // 0x83 x Vcc
    oled_writeLongCmd(data, 2);
    // Set contrast
    data[0] = 0x81;
    data[1] = 0xEF;
    oled_writeLongCmd(data, 2);

    // Set memory addressing mode
    data[0] = 0x20;
    data[1] = 0x00;         // horizontal mode
    oled_writeLongCmd(data, 2);
    // Set segment remap
    oled_writeCmd(0xA1);    // colume 127 -> SEG0
    // Set normal display
    oled_writeCmd(0xA6);
    // Set multiplex ratio
    data[0] = 0xA8;
    data[1] = 0x3f;         // N = 64, default
    oled_writeLongCmd(data, 2);
    // Set COM output scan direction
    oled_writeCmd(0xC8);    // from COM[N-1] to COM0
    // Set COM pin
    data[0] = 0xDA;
    data[1] = 0x12;         // alternative, disable left/right remap, default
    oled_writeLongCmd(data, 2);
    // Set display offset
    data[0] = 0xD3;
    data[1] = 0x00;         // default
    oled_writeLongCmd(data, 2);
    // Set low column address
//    oled_writeCmd(0x00);    // default
    // Set high column address
//    oled_writeCmd(0x10);    // default
    // Set display start line
    oled_writeCmd(0x40);    // default

    // Turn on display
    oled_writeCmd(0xA4);
    // Turn on panel
    oled_writeCmd(0xAF);

    oled_clear();

    return RT_EOK;
}

/***************************************************************************//**
 * @brief
 *   Get the color of a pixel
 *
 * @details
 *
 * @note
 *
 * @param[out] c
 *  Pointer to color
 *
 * @param[in] x
 *  Horizontal position
 *
 * @param[in] y
 *  Vertical position
 ******************************************************************************/
static void oled_getPixel(rtgui_color_t *c, int x, int y)
{
    rt_err_t ret;
    rt_uint8_t color, data[3];

    if ((x >= MINISTM32_OLED_WIDTH) || (y >= MINISTM32_OLED_HEIGHT))
    {
        return;
    }

    if (rt_hw_interrupt_check())
    {
        ret = rt_sem_take(&oled_lock, RT_WAITING_NO);
    }
    else
    {
        ret = rt_sem_take(&oled_lock, RT_WAITING_FOREVER);
    }
    if (ret != RT_EOK)
    {
        return;
    }

    // Set column address
    data[0] = 0x21;
    data[1] = x;
    data[2] = x;
    oled_writeLongCmd(data, 3);

    // Set page address
    data[0] = 0x22;
    data[1] = y / 8;
    data[2] = y / 8;
    oled_writeLongCmd(data, 3);

    oled_readData(&color, 1);
    if (color & (1 << (y % 8)))
    {
        *(rt_uint8_t *)c = 0x01;
    }
    else
    {
        *(rt_uint8_t *)c = 0x00;
    }

    rt_sem_release(&oled_lock);
}

/***************************************************************************//**
 * @brief
 *   Draw a pixel with specified color
 *
 * @details
 *
 * @note
 *
 * @param[in] c
 *  Pointer to color
 *
 * @param[in] x
 *  Horizontal position
 *
 * @param[in] y
 *  Vertical position
 ******************************************************************************/
static void oled_setPixel(rtgui_color_t *c, int x, int y)
{
    rt_err_t ret;
    rt_uint8_t color, data[3];

    if ((x >= MINISTM32_OLED_WIDTH) || (y >= MINISTM32_OLED_HEIGHT))
    {
        return;
    }

    if (rt_hw_interrupt_check())
    {
        ret = rt_sem_take(&oled_lock, RT_WAITING_NO);
    }
    else
    {
        ret = rt_sem_take(&oled_lock, RT_WAITING_FOREVER);
    }
    if (ret != RT_EOK)
    {
        return;
    }

    // Set column address
    data[0] = 0x21;
    data[1] = x;
    data[2] = x;
    oled_writeLongCmd(data, 3);

    // Set page address
    data[0] = 0x22;
    data[1] = y / 8;
    data[2] = y / 8;
    oled_writeLongCmd(data, 3);

    oled_readData(&color, 1);
    color &= ~(1 << (y % 8));
    if (*(rt_uint8_t *)c)
    {
        color |= 1 << (y % 8);
    }
    oled_writeData(&color, 1);

    rt_sem_release(&oled_lock);
}

/***************************************************************************//**
 * @brief
 *   Draw a horizontal line with raw color
 *
 * @details
 *
 * @note
 *
 * @param[in] pixels
 *  Pointer to raw color
 *
 * @param[in] x1
 *  Horizontal start position
 *
 * @param[in] x2
 *  Horizontal end position
 *
 * @param[in] y
 *  Vertical position
 ******************************************************************************/
static void oled_drawRawHLine(rt_uint8_t *pixels, int x1, int x2, int y)
{
    rt_err_t ret;
    rt_uint8_t color[MINISTM32_OLED_WIDTH], data[3];
    rt_uint32_t i;

    if ((x1 >= MINISTM32_OLED_WIDTH) || (y >= MINISTM32_OLED_HEIGHT))
    {
        return;
    }
    if (x2 >= MINISTM32_OLED_WIDTH)
    {
        x2 = MINISTM32_OLED_WIDTH - 1;
    }

    if (rt_hw_interrupt_check())
    {
        ret = rt_sem_take(&oled_lock, RT_WAITING_NO);
    }
    else
    {
        ret = rt_sem_take(&oled_lock, RT_WAITING_FOREVER);
    }
    if (ret != RT_EOK)
    {
        return;
    }

    // Set column address
    data[0] = 0x21;
    data[1] = x1;
    data[2] = x2;
    oled_writeLongCmd(data, 3);

    // Set page address
    data[0] = 0x22;
    data[1] = y / 8;
    data[2] = y / 8;
    oled_writeLongCmd(data, 3);

    oled_readData(color, x2 - x1 + 1);
    for (i = 0; i < x2 - x1; i++)
    {
        color[i] &= ~(1 << (y % 8));
        if (*pixels++)
        {
            color[i] |= 1 << (y % 8);
        }
    }
    oled_writeData(color, x2 - x1 + 1);

    rt_sem_release(&oled_lock);
    oled_debug("rawH (%d-%d, %d) %x\n", x1, x2, y, *pixels);
}

/***************************************************************************//**
 * @brief
 *   Draw a horizontal line with specified color
 *
 * @details
 *
 * @note
 *
 * @param[in] c
 *  Pointer to color
 *
 * @param[in] x1
 *  Horizontal start position
 *
 * @param[in] x2
 *  Horizontal end position
 *
 * @param[in] y
 *  Vertical position
 ******************************************************************************/
static void oled_drawHLine(rtgui_color_t *c, int x1, int x2, int y)
{
    rt_err_t ret;
    rt_uint8_t color[MINISTM32_OLED_WIDTH], data[3];
    rt_uint32_t i;

    if ((x1 >= MINISTM32_OLED_WIDTH) || (y >= MINISTM32_OLED_HEIGHT))
    {
        return;
    }
    if (x2 >= MINISTM32_OLED_WIDTH)
    {
        x2 = MINISTM32_OLED_WIDTH - 1;
    }

    if (rt_hw_interrupt_check())
    {
        ret = rt_sem_take(&oled_lock, RT_WAITING_NO);
    }
    else
    {
        ret = rt_sem_take(&oled_lock, RT_WAITING_FOREVER);
    }
    if (ret != RT_EOK)
    {
        return;
    }

    // Set column address
    data[0] = 0x21;
    data[1] = x1;
    data[2] = x2;
    oled_writeLongCmd(data, 3);

    // Set page address
    data[0] = 0x22;
    data[1] = y / 8;
    data[2] = y / 8;
    oled_writeLongCmd(data, 3);

    oled_readData(color, x2 - x1 + 1);
    for (i = 0; i < x2 - x1; i++)
    {
        color[i] &= ~(1 << (y % 8));
    }
    if (*(rt_uint8_t *)c)
    {
        for (i = 0; i < x2 - x1; i++)
        {
            color[i] |= 1 << (y % 8);
        }
    }
    oled_writeData(color, x2 - x1 + 1);

    rt_sem_release(&oled_lock);
}

/***************************************************************************//**
 * @brief
 *   Draw a vertical line with specified color
 *
 * @details
 *
 * @note
 *
 * @param[in] c
 *  Pointer to color
 *
 * @param[in] x
 *  Horizontal position
 *
 * @param[in] y1
 *  Vertical start position
 *
 * @param[in] y2
 *  Vertical end position
 ******************************************************************************/
static void oled_drawVLine(rtgui_color_t *c, int x , int y1, int y2)
{
    rt_err_t ret;
    rt_uint8_t color[MINISTM32_OLED_HEIGHT], data[3];
    rt_uint32_t i;

    if ((x >= MINISTM32_OLED_WIDTH) || (y1 >= MINISTM32_OLED_HEIGHT))
    {
        return;
    }
    if (y2 >= MINISTM32_OLED_HEIGHT)
    {
        y2 = MINISTM32_OLED_HEIGHT - 1;
    }

    if (rt_hw_interrupt_check())
    {
        ret = rt_sem_take(&oled_lock, RT_WAITING_NO);
    }
    else
    {
        ret = rt_sem_take(&oled_lock, RT_WAITING_FOREVER);
    }
    if (ret != RT_EOK)
    {
        return;
    }

    // Set memory addressing mode
    data[0] = 0x20;
    data[1] = 0x01;         // vertical mode
    oled_writeLongCmd(data, 2);

    // Set column address
    data[0] = 0x21;
    data[1] = x;
    data[2] = x;
    oled_writeLongCmd(data, 3);

    // Set page address
    data[0] = 0x22;
    data[1] = y1 / 8;
    data[2] = y2 / 8;
    oled_writeLongCmd(data, 3);

    oled_readData(color, (y2 - y1 + 1 + 7) / 8);
    if (*(rt_uint8_t *)c)
    {
        for (i = y1; i <= y2; i++)
        {
            color[i / 8] |= 1 << (i % 8);
        }
    }
    else
    {
        for (i = y1; i <= y2; i++)
        {
            color[i / 8] &= ~(1 << (i % 8));
        }
    }
    oled_writeData(color, (y2 - y1 + 1 + 7) / 8);

    // Set memory addressing mode
    data[0] = 0x20;
    data[1] = 0x00;         // horizontal mode
    oled_writeLongCmd(data, 2);

    rt_sem_release(&oled_lock);
    oled_debug(" VLine (%d, %d-%d) %x\n", x, y1, y2, *(rt_uint8_t *)c);
}

/***************************************************************************//**
 * @brief
 *   Open OLED device
 *
 * @details
 *
 * @note
 *
 * @param[in] dev
 *   Pointer to device descriptor
 *
 * @param[in] oflag
 *   Device open flag
 *
 * @return
 *   Error code
 ******************************************************************************/
static rt_err_t miniStm32_oled_open(rt_device_t dev, rt_uint16_t oflag)
{
    return RT_EOK;
}

/***************************************************************************//**
 * @brief
 *   Close OLED device
 *
 * @details
 *
 * @note
 *
 * @param[in] dev
 *   Pointer to device descriptor
 *
 * @return
 *   Error code
 ******************************************************************************/
static rt_err_t miniStm32_oled_close(rt_device_t dev)
{
    return RT_EOK;
}

/*static void miniStm32_oled_update(struct rt_device_rect_info *rect)
{
    rt_uint8_t i, data[3];

    if ((rect->x >= MINISTM32_OLED_WIDTH) || (rect->y >= MINISTM32_OLED_HEIGHT))
    {
        return;
    }

    // Set column address
    data[0] = 0x21;
    data[1] = rect->x;
    if ((rect->x + rect->width) >= MINISTM32_OLED_WIDTH)
    {
        data[2] = MINISTM32_OLED_WIDTH - 1;
    }
    else
    {
        data[2] = rect->x + rect->width;
    }
    oled_writeLongCmd(data, 3);

    // Set page address
    data[0] = 0x22;
    data[1] = rect->y / 8;
    if ((rect->y + rect->height) >= MINISTM32_OLED_HEIGHT)
    {
        data[2] = (MINISTM32_OLED_HEIGHT - 1) / 8;
    }
    else
    {
        data[2] = (rect->y + rect->height) / 8;
    }
    oled_writeLongCmd(data, 3);

    for (i = data[1]; i <= data[2]; i++)
    {
        oled_writeData(&frame_buffer[i][rect->x], rect->width);
    }
}*/

/***************************************************************************//**
* @brief
*   Configure OLED device
*
* @details
*
* @note
*
* @param[in] dev
*   Pointer to device descriptor
*
* @param[in] cmd
*   IIC control command
*
* @param[in] args
*   Arguments
*
* @return
*   Error code
******************************************************************************/
static rt_err_t miniStm32_oled_control(rt_device_t dev, rt_uint8_t cmd, void *args)
{
	switch (cmd)
	{
	case RTGRAPHIC_CTRL_RECT_UPDATE:
//        miniStm32_oled_update((struct rt_device_rect_info *)args);
        oled_debug("OLED: update\n");
		break;
	case RTGRAPHIC_CTRL_POWERON:
		break;
	case RTGRAPHIC_CTRL_POWEROFF:
		break;
	case RTGRAPHIC_CTRL_GET_INFO:
		rt_memcpy(args, &oled_info, sizeof(oled_info));
		break;
	case RTGRAPHIC_CTRL_SET_MODE:
		break;
	}

	return RT_EOK;
}

/***************************************************************************//**
 * @brief
 *	Register OLED device
 *
 * @details
 *
 * @note
 *
 * @param[in] device
 *	Pointer to device descriptor
 *
 * @param[in] name
 *	Device name
 *
 * @param[in] flag
 *	Configuration flags
 *
 * @param[in] iic
 *	Pointer to IIC device descriptor
 *
 * @return
 *	Error code
 ******************************************************************************/
static rt_err_t miniStm32_oled_register(
	rt_device_t	        device,
	const char          *name,
	rt_uint32_t         flag,
	void                *data)
{
	RT_ASSERT(device != RT_NULL);

	device->type 		= RT_Device_Class_Graphic;
	device->rx_indicate = RT_NULL;
	device->tx_complete = RT_NULL;
	device->init 		= RT_NULL;
	device->open		= miniStm32_oled_open;
	device->close		= miniStm32_oled_close;
	device->read 		= RT_NULL;
	device->write 		= RT_NULL;
	device->control 	= miniStm32_oled_control;
	device->user_data	= data;

	/* register a character device */
	return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag);
}

/***************************************************************************//**
 * @brief
 *   Initialize OLED device
 *
 * @details
 *
 * @note
 *
 ******************************************************************************/
void miniStm32_hw_oled_init(void)
{
    rt_uint32_t flag;
    rt_uint8_t status;

    do
    {
        /* Init OLED info */
        flag = RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE; //RT_DEVICE_FLAG_DMA_TX
        oled_info.pixel_format      = RTGRAPHIC_PIXEL_FORMAT_MONO;
        oled_info.bits_per_pixel    = 1;
        oled_info.width             = MINISTM32_OLED_WIDTH;
        oled_info.height            = MINISTM32_OLED_HEIGHT;
        oled_info.framebuffer       = RT_NULL; //(rt_uint8_t *)frame_buffer;
//        if (miniStm32_oled_register(&oled_device, OLED_DEVICE_NAME, flag, RT_NULL) != RT_EOK)
        if (miniStm32_oled_register(&oled_device, OLED_DEVICE_NAME, flag,
            (void *)&oled_ops) != RT_EOK)
        {
            break;
        }

        /* Init OLED lock */
        if (rt_sem_init(&oled_lock, OLED_DEVICE_NAME, 1, RT_IPC_FLAG_FIFO) != RT_EOK)
        {
            break;
        }

        /* Init ssd1306 */
        if (ssd1306_init() != RT_EOK)
        {
            break;
        }

        oled_readStatus(&status);
        oled_debug("OLED: status %x\n", status);

        /* Set as rtgui graphic driver */
        if (rtgui_graphic_set_device(&oled_device) != RT_EOK)
        {
            break;
        }

        oled_debug("OLED: H/W init OK!\n");
        return;
    } while(0);

    oled_debug("OLED err: H/W init failed!\n");
}

#endif /* defined(MINISTM32_USING_OLED) */
/***************************************************************************//**
 * @}
 ******************************************************************************/

drv_oled.h

/***************************************************************************//**
 * @file 	dev_oled.h
 * @brief 	OLED driver of RT-Thread RTOS for MiniSTM32
 * 	COPYRIGHT (C) 2012, RT-Thread Development Team
 * @author 	onelife
 * @version 1.0
 *******************************************************************************
 * @section License
 * The license and distribution terms for this file may be found in the file
 *  LICENSE in this distribution or at http://www.rt-thread.org/license/LICENSE
 *******************************************************************************
 * @section Change Logs
 * Date			Author		Notes
 * 2012-06-15	onelife		Initial creation for MiniSTM32
 ******************************************************************************/
#ifndef __DEV_OLED_H__
#define __DEV_OLED_H__

/* Includes ------------------------------------------------------------------*/
/* Exported types ------------------------------------------------------------*/
/* Exported constants --------------------------------------------------------*/
/* Exported macro ------------------------------------------------------------*/
#define MINISTM32_OLED_WIDTH            (128)   /* Screen Width (in pixels) */
#define MINISTM32_OLED_HEIGHT           (64)    /* Screen Hight (in pixels) */

#define MINISTM32_OLED_CTRL_SUSPEND     (0x00)
#define MINISTM32_OLED_CTRL_RESUME      (0x01)

#define	MINISTM32_OLED_DATA_IN(data)    (*(data) = GPIOB->IDR & 0x000000FF)
#define	MINISTM32_OLED_DATA_OUT(data)   (GPIOB->ODR = (GPIOB->ODR & 0xFFFFFF00) | data)
#define	MINISTM32_OLED_CS_SET           (GPIOC->BSRR = GPIO_Pin_9)
#define	MINISTM32_OLED_DC_SET           (GPIOC->BSRR = GPIO_Pin_8)
#define	MINISTM32_OLED_WR_SET           (GPIOC->BSRR = GPIO_Pin_7)
#define	MINISTM32_OLED_RD_SET           (GPIOC->BSRR = GPIO_Pin_6)
#define	MINISTM32_OLED_CS_RESET         (GPIOC->BRR = GPIO_Pin_9)
#define	MINISTM32_OLED_DC_RESET         (GPIOC->BRR = GPIO_Pin_8)
#define	MINISTM32_OLED_WR_RESET         (GPIOC->BRR = GPIO_Pin_7)
#define	MINISTM32_OLED_RD_RESET         (GPIOC->BRR = GPIO_Pin_6)

#define	MINISTM32_OLED_DATA_CLOCK       (RCC_APB2Periph_GPIOB)
#define	MINISTM32_OLED_CTRL_CLOCK       (RCC_APB2Periph_GPIOC)
#define	MINISTM32_OLED_DATA_PORT        (GPIOB)
#define	MINISTM32_OLED_CTRL_PORT        (GPIOC)
#define	MINISTM32_OLED_CS_PIN           (GPIO_Pin_9)
#define	MINISTM32_OLED_DC_PIN           (GPIO_Pin_8)
#define	MINISTM32_OLED_WR_PIN           (GPIO_Pin_7)
#define	MINISTM32_OLED_RD_PIN           (GPIO_Pin_6)

/* Exported functions ------------------------------------------------------- */
void miniStm32_hw_oled_init(void);

#endif /* __DEV_OLED_H__ */

pixel_driver.c (修改部分)

static void _pixel_mono_set_pixel(rtgui_color_t *c, int x, int y)
{
	rt_uint8_t pixel;

	pixel = rtgui_color_to_mono(*c);
	gfx_device_ops->set_pixel((char*)&pixel, x, y);
}

static void _pixel_mono_get_pixel(rtgui_color_t *c, int x, int y)
{
	rt_uint8_t pixel;

	gfx_device_ops->get_pixel((char*)&pixel, x, y);
	*c = rtgui_color_from_mono(pixel);
}

static void _pixel_mono_draw_hline(rtgui_color_t *c, int x1, int x2, int y)
{
	rt_uint8_t pixel;

	pixel = rtgui_color_to_mono(*c);
	gfx_device_ops->draw_hline((char*)&pixel, x1, x2, y);
}

static void _pixel_mono_draw_vline(rtgui_color_t *c, int x, int y1, int y2)
{
	rt_uint8_t pixel;

	pixel = rtgui_color_to_mono(*c);
	gfx_device_ops->draw_vline((char*)&pixel, x, y1, y2);
}

static void _pixel_draw_raw_hline(rt_uint8_t *pixels, int x1, int x2, int y)
{
	gfx_device_ops->blit_line((char*)pixels, x1, x2, y);
}

const struct rtgui_graphic_driver_ops _pixel_mono_ops =
{
	_pixel_mono_set_pixel,
	_pixel_mono_get_pixel,
	_pixel_mono_draw_hline,
	_pixel_mono_draw_vline,
	_pixel_draw_raw_hline,
};

const struct rtgui_graphic_driver_ops *rtgui_pixel_device_get_ops(int pixel_format)
{
	switch (pixel_format)
	{
    case RTGRAPHIC_PIXEL_FORMAT_MONO:
        return &_pixel_mono_ops;

	case RTGRAPHIC_PIXEL_FORMAT_RGB565:
		return &_pixel_rgb565_ops;

	case RTGRAPHIC_PIXEL_FORMAT_RGB565P:
		return &_pixel_rgb565p_ops;

	case RTGRAPHIC_PIXEL_FORMAT_RGB888:
		return &_pixel_rgb888_ops;
	}

	return RT_NULL;
}

color.h (修改部分)

/* convert rtgui color to mono */
rt_inline rt_uint8_t rtgui_color_to_mono(rtgui_color_t c)
{
	rt_uint8_t pixel;

	pixel = (RTGUI_RGB_R(c) | RTGUI_RGB_G(c) | RTGUI_RGB_B(c)) ? 0x01 : 0x00;
	return pixel;
}

rt_inline rtgui_color_t rtgui_color_from_mono(rt_uint8_t pixel)
{
	rtgui_color_t color;

	if (pixel)
	{
    	color = white;
	}
    else
    {
        color = black;
    }
	return color;
}

文章转自： http://piao.sg/onelife/?p=213#comment-8


                

        

        

    




    

      

        

            

              
                
                  hank_fan5
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    2
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    23
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  4
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
SSD1306 OLED 1.3" IIC 驱动 带字库 中英文混合显示

				
			

			

				

					avayan8006的博客
				

				

					09-03
					
					1780
					
				

			

		

		

			
				
早就听说OLED显示效果比较好，也不需要背光，使用起来接线也很方便，于是TB上买了一个1.3Inch的OLED，蓝色的字，显示效果确实非常好，下边就分享一下驱动过程
我在STM32F103C8T6这块单片机上调试的，硬件上我的屏幕是IIC接口的，没有用硬件I2C 而是模拟的，PB4->SCL PB6->SDA ，屏幕地址0x78，字库用的M25Q16 2MB字节
字库包含...

			
		

	



                

              
                



	

		

			

				
					
SSD1306规格OLED驱动库（STM32版），包含16x16汉字、字母写入函数

				
			

			

				

					在知识与无知里反复横跳。
				

				

					04-15
					
					6787
					
				

			

		

		

			
				
这里写目录标题前言OLED一、像素二、页结构纵向结构横向结构注意事项字库oled_font.h一、字库介绍二、制作字库PCtoLCD2002
前言
在很多项目中OLED屏幕的使用都是很常见的，可以作为调试信息的输出以及用于用户交互。
一般的项目我们只需要能实现一些简单的功能就行，比如写入汉字以及字母就行，所以我将这两个功能打包成函数，方便调用。
项目工程我会放到文章最后，需要的可以下载使用。
OLED
一、像素
1、我使用的这款OLED是128x64大小的，也就是这个屏幕一共有128x64 = 8192的发

			
		

	



                


  
              

                


	

		

			

				
					
FPGA驱动0.96寸OLED（SSD1306）

				
			

			

				

					LionelZhao的博客
				

				

					01-16
					
					4643
					
				

			

		

		

			
				
FPGA实现SPI写模式（用于SSD1603的0.91寸OLED驱动）_LionelZhao的博客-CSDN博客。

			
		

	





	

		

			

				
					
软件iic驱动SSD1306的OLED（C8T6)

					
最新发布

				
			

			

				

					abc565846881的博客
				

				

					03-30
					
					271
					
				

			

		

		

			
				
最近做了一个小项目，总结了一下oled的驱动代码，方便大家使用。实测可用，注意修改自己的引脚还有初始化gpio即可。

			
		

	



		

			
		



	

		

			

				
					
0.96寸OLED（SSD1306）屏幕显示（一）——基础功能介绍

					
热门推荐

				
			

			

				

					qq_35953617的博客
				

				

					12-27
					
					7万+
					
				

			

		

		

			
				
最近，我突发奇想去翻阅了一些我本科期间所做的一些小项目，发现都挺有意思的！当年做这些项目的时候可走了很多弯路，所以想着可以将它们上传到网络上，并通过我的讲解文章可以帮助你们少走一些弯路！今天，我要分享的是一个0.96寸OLED（SSD1306）屏幕显示的学习笔记，因为我想要讲的详细一点，所以打算做成一个系列，手把手地教你学习和认识屏幕显示。由于我知识有限，如果出现一些错误，希望大家可以帮助我指出来，我们一起学习进步！！！OLED，即有机发光二极管OLED由于同时具备。

			
		

	





	

		

			

				
					
I²C总线协议梳理附STM32平台I2C总线SSD1306OLED屏幕软件模拟方式驱动

				
			

			

				

					今届入室,众流剋上
				

				

					06-16
					
					656
					
				

			

		

		

			
				
I²C也采用串行通信的思想；是一种简单的双向两线制的半双工总线协议，其引脚少，硬件实现简单，扩展性强，以I2C（之后均已I2C，IIC代指I²C，Inter-Integrated circuit）地址进行设备选择，相较SPI协议省去了片选线。I2C协议标准涉及OSI模型的物理层，数据链路层和网络层。

			
		

	





	

		

			

				
					
Micropython ssd1306 oled驱动程序

				
			

			

				

					03-01
				

			

		

		

			
				
这是一个 Micropython 驱动程序，用于控制 OLED SSD1306 显示屏。该驱动程序允许通过 Micropython 在 ESP32、ESP8266 或其他支持 Micropython 的微控制器上轻松控制 OLED 显示屏，从而实现文字、图形等内容的显示。...

			
		

	





	

		

			

				
					
SSD 1306OLED驱动芯片中文手册

				
			

			

				

					02-27
				

			

		

		

			
				
包含结构方框图、功能块描述等，SSD1306是一个单片 CMOS OLED/PLED驱动芯片可以驱动有机 / 聚合发光二极管点阵图形显 示系统。

			
		

	





	

		

			

				
					
ssd1306 OLED驱动例程与规格书.rar

				
			

			

				

					01-02
				

			

		

		

			
				
ssd1306 OLED驱动例程与芯片规格书

			
		

	





	

		

			

				
					
SSD1306OLED驱动芯片中文手册.pdf

				
			

			

				

					08-17
				

			

		

		

			
				
ssd1306中文版手册 SSD1306是一个单片 CM,OS OLED/PLED驱动芯片可以驱动有机/聚合发光二极管点阵图像显示系统。

			
		

	





	

		

			

				
					
STM32 I2C 12864 ssd1306 0.96寸 OLED 屏幕 HAL 库功能封装和样例

				
			

			

				

					10-01
				

			

		

		

			
				
STM32F103C8T6 之下通过 cubeMX 配置硬件 i2c 输出到 0.96 寸 OLED 屏幕输出显示的样例和驱动的封装（基于 HAL）。

其他芯片一样可以使用，只要配置好引脚即可。

本驱动参考了硬石样例，与之不同的是，硬石是软件输出 i2c， 本样例是 stm32 硬件输出。

啰嗦一句：作此驱动一为学习，二为以后的开发，能有个实时输出 debug 信息的小屏幕。

			
		

	





	

		

			

				
					
ssd1306-stm32HAL:使用hal库的stm32的ssd1306库

				
			

			

				

					05-09
				

			

		

		

			
				
ssd1306-stm32HAL
 使用stm32-hal库的stm32的ssd1306库。 该库可与i2c一起使用，并且默认情况下为128x64 oled面板配置。
 如果搜索4线SPI支持，则可以在分支中找到它。
用法
编译并链接项目中的库文件。
 - font.c 
- ssd1306.c
在示例文件夹中找到了stm32f411发现的完整示例。
 小例子：
 #include "ssd1306.h"
#include "fonts.h"
I2C_HandleTypeDef hi2c1;
// Init lcd using one of the stm32HAL i2c typedefs
ssd1306_Init(&hi2c1);
// Write data to local screenbuffer
ssd1306_SetCursor(0, 36);
ssd1306_WriteStr

			
		

	





	

		

			

				
					
stm32HAL库驱动SSD1306oled的库文件.zip

				
			

			

				

					04-22
				

			

		

		

			
				
stm32HAL库驱动SSD1306oled的库文件
包含驱动测试例程
通过宏定义可选SPI和I2C和DMA
个人写的代码
移植需要一定的基础

			
		

	





	

		

			

				
					
stm32 spi模式点OLED屏（096_SSD1306）

				
			

			

				

					12-26
				

			

		

		

			
				
STM32 4线SPI模式点OLED（SSD1306驱动）屏。
无字库驱动。
详细描述见博客：https://blog.csdn.net/wodenidejingaide/article/details/85269244


			
		

	





	

		

			

				
					
SSD1306(OLED驱动芯片)指令详解

				
			

			

				

					09-13
				

			

		

		

			
				
SSD1306 (OLED驱动芯片) 指令详解手册，OLED，12864。

			
		

	





	

		

			

				
					
SSD1306 OLED驱动芯片中文手册.pdf

				
			

			

				

					08-04
				

			

		

		

			
				
SSD1306 OLED驱动芯片中文手册.pdf

			
		

	





	

		

			

				
					
0.96寸OLED屏幕控制器SSD1306详解

				
			

			

				

					博客
				

				

					12-12
					
					1万+
					
				

			

		

		

			
				
上一篇文章采用单片机cx32l003驱动了0.96寸OLED屏幕并实现其点亮。

《CX32l003 点亮0.96寸OLED屏幕》。

这一篇将在前面的基础上对这个屏幕进行详细讲解，尤其是一些屏幕控制器SSD1306比较重要的命令。





根据第9节COMMAND TABLE进行描述



（Fundamental Command Table）



0X81 xx：

根据命令描述，这是一个双字节命令，从256个对比度中选择1个，对比度随着值得增加而增加。程序中输入的是0x7f值，最高为0xff。..

			
		

	





	

		

			

				
					
arduino ssd1306oled显示屏

				
			

			

				

					06-28
				

			

		

		

			
				
### 回答1：
Arduino SSD1306 OLED显示屏是一种基于Arduino开发板的显示屏，采用SSD1306驱动芯片，具有高亮度、低功耗、高对比度等特点。它可以用于显示各种信息，如文本、图像、图标等，适用于各种Arduino项目。   

### 回答2：
Arduino SSD1306 OLED显示屏是一块高分辨率的单色显示屏，非常适合DIY电子爱好者在自己的项目中使用。与传统的LCD显示屏不同，OLED显示屏具有更快的响应速度、更低的功耗和更高的对比度，同时消耗的电力也更少，在相同的亮度下更加节能，因此在需要使用电池供电的项目中得到广泛应用。Arduino SSD1306 OLED显示屏由OLED屏幕、驱动IC、电容、电阻和其他一些辅助器件组成，通过I2C总线与Arduino板通信。

为了控制这块显示屏，我们需要一个专门编写的程序。在这个程序中，我们可以定义需要显示的内容，包括文本、图形、图标和图像。可以通过设置显示屏坐标和颜色来创建自定义的显示内容。可以使用不同的字体、大小和样式来创建独特的设计。

使用Arduino SSD1306 OLED显示屏的优点不只是它的高效能和易用性，还在于其开放性和扩展性。用户可以使用不同的软件库和驱动程序来创建自己的创新项目，或者使用可用的库和例子来快速上手。对于那些不熟悉编程的用户，也可以使用现成的图形库来轻松地创建复杂的图形和界面。

总的来说，Arduino SSD1306 OLED显示屏是一款多功能的单色显示屏，其灵活性和高效能使其成为DIY电子爱好者的首选。适用于各种类型的项目，包括智能家居、传感器网络、机器人、万花筒、数据可视化和可穿戴设备。   

### 回答3：
Arduino ssd1306 oled显示屏是一种非常常见和实用的显示屏，其特点是高亮度、高对比度、低功耗、反应速度快等。这种显示屏采用SSD1306控制芯片，可以通过I2C接口与Arduino连接。SSD1306控制芯片集成了控制器和驱动器，可以通过软件控制屏幕内容。

要使用Arduino ssd1306 oled显示屏，首先需要下载并安装相应的库。在Arduino IDE中打开菜单“工具”-“库管理器”，搜索SSD1306并下载“Adafruit SSD1306”或者“U8g2”库。接下来，连接Arduino ssd1306 oled显示屏到Arduino板上，将VCC连接到5V，GND连接到GND，SDA连接到SDA，SCL连接到SCL。在Arduino IDE中选择正确的板子和端口，并打开一个新的示例程序。如果已安装了U8g2库，可以在示例中找到ssd1306的例子程序进行测试。

在程序中，可以通过调用相应函数来控制显示屏上显示内容，例如显示文本、图形、动画等。可以设置屏幕分辨率、字体大小、对齐方式等缩放和定位属性。可以使用函数来绘制点、线、矩形、圆形、多边形等基本图形，也可以导入和显示位图和动画等多媒体内容。

总的来说，Arduino ssd1306 oled显示屏是一种非常实用和常用的显示屏，可以用于各种跟踪、监控、测量、控制等应用场景。通过简单的硬件和软件设计，可以快速、方便、高效地实现其功能。在今后的开发中，Arduino ssd1306 oled显示屏将会得到更广泛的应用和发展。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 4

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值