SSD1306/SSD1315 OLED显示屏滚动显示的两种方案

    对于OLED的显示来说，单独的静态显示比较简单，但是显示的效果较为呆板，并且如果一行里需要显示的内容太多，静态显示就无法满足实际的显示需求了，这时候就需要采取动态滚动显示的方案来在一行的空间里显示更多的内容，也可以增强显示的效果。

    常用的动态显示的方案有两种，一是采用硬件实现，这种方案在编程时比较简单，只需要设置几个寄存器即可，但是能不能使用硬件来实现还要取决于驱动模块是否支持；二是采用软件实现，通过软件来刷屏实现滚动显示的效果。因为项目需求，有幸使用这两种方案进行过测试，下面就说一下这两种方案在使用时的个人感受吧。

    硬件实现方案，项目中使用到的OLED驱动模块为SSD1315，通过查看datasheet，可以确认该模块支持硬件的滚动显示功能，可以通过发送几条特定的指令实现水平滚动、垂直滚动以及斜向的滚动，还可以设置滚动区域和滚动速度，在使用时还是比较方便的，设置起来也比较简单，但是，若需要显示的字符串长度超过了OLED的分辨率，就会导致字符串显示不全，比如说128*64分辨率的OLED，若显示8*16分辨率的字符，则一行最多显示16个字符，若想让其滚动显示17个字符的话硬件的方式就不能实现了。

#define OLED_CMD_SCROLL_H_RIGHT  0x26
#define OLED_CMD_SCROLL_H_LEFT   0x27
#define OLED_CMD_CONTINUOUS_SCROLL_V_AND_H_RIGHT 0x29
#define OLED_CMD_CONTINUOUS_SCROLL_V_AND_H_LEFT 0x2A
#define OLED_CMD_DEACTIVATE_SCROLL 0x2E
#define OLED_CMD_ACTIVATE_SCROLL 0x2F
#define OLED_CMD_SET_VERTICAL_SCROLL_AREA 0xA3


void ssd1315_scrolling_setup(uint16_t scoll_mode,uint16_t start_page,uint16_t end_page,uint16_t frequency)
{
    OLED_write_command(scoll_mode);        //right/left horizontal scroll
    OLED_write_command(0x00);              //dummy byte(set as 0x00)
    OLED_write_command(start_page);        //start page address
    OLED_write_command(frequency);         //scroll frequency
    OLED_write_command(end_page);          //end page address
    OLED_write_command(0x00);              //dummy byte(set as 0x00)
    OLED_write_command(0xFF);              //dummy byte(set as 0xFF)
}

void ssd1315_scroll_start(void)
{
    OLED_write_command(0x2F);
}

void ssd1315_scroll_stop(void)
{
    OLED_write_command(0x2E);
}

      软件实现方案，软件实现的方案主要就是用过不停的刷屏来实现滚动显示的效果，在视觉效果上跟硬件差不多，并且可以解决硬件方案上不能解决的显示长字符串的需求，但是程序上会复杂很多。

void oled_write_text(uint8_t* array, uint8_t coll, uint8_t line, uint16_t loop_ptr, uint8_t s_width)
{
    uint8_t i = 0,k = 0;
    uint8_t *array_a,*array_b;
    uint8_t m = 0,n = 0;
    uint8_t rx_buffer[8];

    array_a = array;

    m = (uint8_t)(loop_ptr >> 3);
    n = (uint8_t)(loop_ptr % 8);

    array_a += m;
    array_b = array_a;

    OLED_set_column_address(coll);
    OLED_set_page_address(line);

    for(k = 0; k <= s_width; k++)
    {
        if(*(array_a) == 255)  //lsat char
        {
            array_a = array;
        }

        /*16*16分辨率字符*/
        if(*array_a < 200)
        {
            if((*array_a == *(array_a - 1)) && (array_a != array)
            {
                SST25VF_Bufferread(rx_buffer,(*array_a) * 0x20 + 8,8);
            }
            else
            {
                SST25VF_Bufferread(rx_buffer,(*array_a) * 0x20,8);
            }
        }
        
        /*16*8分辨率字符*/
        if((*array_a < 255) && (*array_a >= 200))
        {
            SST25VF_Bufferread(rx_buffer,((*array_a) - 200) * 0x10 + 0x008000,8);
        }

        if(k == 0)
        {
            for(i = n; i < 8; i++)
            {
                OLED_write_data(rx_buffer[i]);
            }
        }
        else if(k <= s_width)
        {
            for(i = 0; i < 8; i++)
            {
                OLED_write_data(rx_buffer[i]);
            }
        }
        else
        {
            for(i = n; i < n; i++)
            {
                OLED_write_data(rx_buffer[i]);
            }
        }
        
        array_a ++;
        
    }

    OLED_set_column_address(coll);
    OLED_set_page_address(line + 1);

    for(k = 0; k <= s_width; k++)
    {
        if(*(array_b) == 255)  //lsat char
        {
            array_b = array;
        }

        /*16*16分辨率字符*/
        if(*array_b < 200)
        {
            if((*array_b == *(array_b - 1)) && (array_b != array)
            {
                SST25VF_Bufferread(rx_buffer,(*array_b) * 0x20 + 0x18,8);
            }
            else
            {
                SST25VF_Bufferread(rx_buffer,(*array_b) * 0x20 + 0x10,8);
            }
        }
        
        /*16*8分辨率字符*/
        if((*array_b < 255) && (*array_b >= 200))
        {
            SST25VF_Bufferread(rx_buffer,((*array_a) - 200) * 0x10 + 0x008008,8);
        }

        if(k == 0)
        {
            for(i = (8 + n); i < 16; i++)
            {
                OLED_write_data(rx_buffer[i - 8]);
            }
        }
        else if(k <= s_width)
        {
            for(i = 8; i < 16; i++)
            {
                OLED_write_data(rx_buffer[i - 8]);
            }
        }
        else
        {
            for(i = 8; i < (8 + n); i++)
            {
                OLED_write_data(rx_buffer[i - 8]);
            }
        }
        
        array_b ++;
        
    }
}

void oled_write_text_roll(uint8_t* array, uint16_t loop_ptr, uint16_t length)
{
    uint8_t array_m[64];
    uint8_t i = 0, j = 0;

    for(i = 0, j = 0; i < ((length + 8) >> 3); i++, j++)
    {
        if(array[j] < 200)
        {
            array_m[i] = array[j];
            array_m[i+1] = array[j];
            i ++;
        }
        else
        {
            array_m[i] = array[j];
        }
    }
    
    oled_write_text(&array_m[0], 2, 6, loop_ptr, 16);
}

        在使用时，只需要周期性调用该函数即可。

    loop ++;
    if(loop == scroll_time)
    {
        loop_ptr++;
        if(loop_ptr >= length) /*length为字符宽度，其中一个16*16分辨率的length为16，一个16*8        分辨率字符的length为8*/
        {
            loop_ptr = 0;
        }
        oled_write_text_roll(array,loop_ptr,length);
        loop = 0;
    }

       

VID_20230105_160415[1]