EasyArm-i.mx280a开发板入门-1.3寸OLED 128X64显示（WSL+ubuntu20.04）

最新推荐文章于 2024-08-12 11:01:25 发布
最新推荐文章于 2024-08-12 11:01:25 发布
阅读量579 收藏 19
点赞数 19
文章标签： 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/brightsm/article/details/140859996
版权

开发板硬件连接：

 

github上找到个linux ssd1306的oled显示代码：

/home/dengxm2024/linuxProgDir/userside_code/ssd1306-linux-master/linux_i2c.c

#include <stdint.h>
#include <stdlib.h>
#include <inttypes.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/i2c-dev.h>

static int file_i2c = 0;

uint8_t _i2c_init(int i2c, int dev_addr)
{
	if (file_i2c == 0)
	{
		char filename[32];
  		sprintf(filename, "/dev/i2c-%d", i2c); // I2C bus number passed
		file_i2c = open(filename, O_RDWR);
		if (file_i2c < 0)
		{
			file_i2c = 0;
			return 1;
		}
		if (ioctl(file_i2c, I2C_SLAVE, dev_addr) < 0) // set slave address
		{
			close(file_i2c);
			file_i2c = 0;
			return 1;
		}
		return 0;
	}
	
	// assume done init already
	return 0;
}

uint8_t _i2c_close()
{
	if (file_i2c != 0)
	{
		close(file_i2c);
		file_i2c = 0;
		return 0;
	}
	
	return 1;
}

uint8_t _i2c_write(uint8_t* ptr, int16_t len)
{
	if (file_i2c == 0 || ptr == 0 || len <= 0)
		return 1;
				
	write(file_i2c, ptr, len);
	
	return 0;
}

uint8_t _i2c_read(uint8_t *ptr, int16_t len)
{
	if (file_i2c == 0 || ptr == 0 || len <= 0)
		return 1;
				
	read(file_i2c, ptr, len);

	return 0;
}

/home/dengxm2024/linuxProgDir/userside_code/ssd1306-linux-master/linux_i2c.h

#ifndef __LINUX_I2C_H__

#define __LINUX_I2C_H__



uint8_t _i2c_init(int i2c, int dev_addr);

uint8_t _i2c_close();

uint8_t _i2c_write(uint8_t* ptr, int16_t len);

uint8_t _i2c_read(uint8_t *ptr, int16_t len);

#endif

/home/dengxm2024/linuxProgDir/userside_code/ssd1306-linux-master/main.c

#include <stdint.h>
#include <stdlib.h>
#include <inttypes.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>

#include "ssd1306.h"

void print_help()
{
    printf("help message\n\n");
    printf("-I\t\tinit oled (128x32 or 128x64 or 64x48)\n");
    printf("-c\t\tclear (line number or all)\n");
    printf("-d\t\t0/display off 1/display on\n");
    printf("-f\t\t0/small font 5x7 1/normal font 8x8 (default normal font)\n");
    printf("-h\t\thelp message\n");
    printf("-i\t\t0/normal oled 1/invert oled\n");
    printf("-l\t\tput your line to display\n");
    printf("-m\t\tput your strings to oled\n");
    printf("-n\t\tI2C device node address (0,1,2..., default 0)\n");
    printf("-r\t\t0/normal 180/rotate\n");
    printf("-x\t\tx position\n");
    printf("-y\t\ty position\n");
}

int main(int argc, char **argv)
{
    uint8_t i2c_node_address = 0;
    int x = -1;
    int y = -1;
    char line[25] = {0};
    char msg[200] = {0};
    char oled_type[10] = {0};
    int clear_line = -1;
    int clear_all = -1;
    int orientation = -1;
    int inverted = -1;
    int display = -1;
    int font = 0;
    
    int cmd_opt = 0;
    
    while(cmd_opt != -1) 
    {
        cmd_opt = getopt(argc, argv, "I:c::d:f:hi:l:m:n:r:x:y:");

        /* Lets parse */
        switch (cmd_opt) {
            case 'I':
                strncpy(oled_type, optarg, sizeof(oled_type));
                break;
            case 'c':
                if (optarg)
                {
                    clear_line = atoi(optarg);
                }
                else
                {
                    clear_all = 1;
                }
                break;
            case 'd':
                display = atoi(optarg);
                break;
            case 'f':
                font = atoi(optarg);
                break;
            case 'h':
                print_help();
                return 0;
            case 'i':
                inverted = atoi(optarg);
                break;
            case 'l':
                strncpy(line, optarg, sizeof(line));
                break;
            case 'm':
                strncpy(msg, optarg, sizeof(msg));
                break;    
            case 'n':
                i2c_node_address = (uint8_t)atoi(optarg);
                break;
            case 'r':
                orientation = atoi(optarg);
                if (orientation != 0 && orientation != 180)
                {
                    printf("orientation value must be 0 or 180\n");
                    return 1;
                }
                break;
            case 'x':
                x = atoi(optarg);
                break;
            case 'y':
                y = atoi(optarg);
                break;
            case -1:
                // just ignore
                break;
            /* Error handle: Mainly missing arg or illegal option */
            case '?':
                if (optopt == 'I')
                {
                    printf("prams -%c missing oled type (128x64/128x32/64x48)\n", optopt);
                    return 1;
                }
                else if (optopt == 'd' || optopt == 'f' || optopt == 'i')
                {
                    printf("prams -%c missing 0 or 1 fields\n", optopt);
                    return 1;
                }
                else if (optopt == 'l' || optopt == 'm')
                {
                    printf("prams -%c missing string\n", optopt);
                    return 1;
                }
                else if (optopt == 'n')
                {
                    printf("prams -%c missing 0,1,2... I2C device node number\n", optopt);
                    return 1;
                }
                else if (optopt == 'r')
                {
                    printf("prams -%c missing 0 or 180 fields\n", optopt);
                    return 1;
                }
                else if (optopt == 'x' || optopt == 'y')
                {
                    printf("prams -%c missing coordinate values\n", optopt);
                    return 1;
                }
                break;
            default:
                print_help();
                return 1;
        }
    }
    
    uint8_t rc = 0;
    
    // open the I2C device node
    rc = ssd1306_init(i2c_node_address);
    
    if (rc != 0)
    {
        printf("no oled attached to /dev/i2c-%d\n", i2c_node_address);
        return 1;
    }
    
    // init oled module
    if (oled_type[0] != 0)
    {
        if (strcmp(oled_type, "128x64") == 0)
            rc += ssd1306_oled_default_config(64, 128);
        else if (strcmp(oled_type, "128x32") == 0)
            rc += ssd1306_oled_default_config(32, 128);
        else if (strcmp(oled_type, "64x48") == 0)
            rc += ssd1306_oled_default_config(48, 64);
    }
    else if (ssd1306_oled_load_resolution() != 0)
    {
        printf("please do init oled module with correction resolution first!\n");
        return 1;
    }
    
    // clear display
    if (clear_all > -1)
    {
        rc += ssd1306_oled_clear_screen();
    }
    else if (clear_line > -1)
    {
        rc += ssd1306_oled_clear_line(clear_line);
    }
    
    // set rotate orientation
    if (orientation > -1)
    {
        rc += ssd1306_oled_set_rotate(orientation);
    }
    
    // set oled inverted
    if (inverted > -1)
    {
        rc += ssd1306_oled_display_flip(inverted);
    }
    
    // set display on off
    if (display > -1)
    {
        rc += ssd1306_oled_onoff(display);
    }
    
    // set cursor XY
    if (x > -1 && y > -1)
    {
        rc += ssd1306_oled_set_XY(x, y);
    }
    else if (x > -1)
    {
        rc += ssd1306_oled_set_X(x);
    }
    else if (y > -1)
    {
        rc += ssd1306_oled_set_Y(y);
    }
    
    // print text
    if (msg[0] != 0)
    {
        rc += ssd1306_oled_write_string(font, msg);
    }
    else if (line[0] != 0)
    {
        rc += ssd1306_oled_write_line(font, line);
    }    
    
    // close the I2C device node
    ssd1306_end();
    
    return rc;
}

 /home/dengxm2024/linuxProgDir/userside_code/ssd1306-linux-master/ssd1306.c

#include <stdint.h>
#include <stdlib.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>

#include "linux_i2c.h"
#include "ssd1306.h"
#include "font.h"

const char init_oled_type_file[] = "/tmp/.ssd1306_oled_type";

static uint8_t data_buf[1024];
static uint8_t max_lines = 0;
static uint8_t max_columns = 0;
static uint8_t global_x = 0;
static uint8_t global_y = 0;

uint8_t ssd1306_init(uint8_t i2c_dev)
{
    uint8_t rc;
    rc = _i2c_init(i2c_dev, SSD1306_I2C_ADDR);
    if (rc > 0)
        return rc;
        
    // test i2c connection
    uint8_t cmd = SSD1306_COMM_CONTROL_BYTE;
    uint8_t result = 0;
    _i2c_write(&cmd, 1);
    _i2c_read(&result, 1);
    if (result == 0)
        return 1;
    
    return 0;
}

uint8_t ssd1306_end()
{
    return _i2c_close();
}

uint8_t ssd1306_oled_onoff(uint8_t onoff)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    if (onoff == 0)
        data_buf[1] = SSD1306_COMM_DISPLAY_OFF;
    else
        data_buf[1] = SSD1306_COMM_DISPLAY_ON;
    
    return _i2c_write(data_buf, 2);
}

uint8_t ssd1306_oled_horizontal_flip(uint8_t flip)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    if (flip == 0)
        data_buf[1] = SSD1306_COMM_HORIZ_NORM;
    else
        data_buf[1] = SSD1306_COMM_HORIZ_FLIP;
    
    return _i2c_write(data_buf, 2);
}

uint8_t ssd1306_oled_display_flip(uint8_t flip)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    if (flip == 0)
        data_buf[1] = SSD1306_COMM_DISP_NORM;
    else
        data_buf[1] = SSD1306_COMM_DISP_INVERSE;
    
    return _i2c_write(data_buf, 2);
}

// 128x32 please use value 32
// 128x64 please use value 64
uint8_t ssd1306_oled_multiplex(uint8_t row)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_MULTIPLEX;
    data_buf[2] = row - 1;
    
    return _i2c_write(data_buf, 3);
}

// offset range 0x00~0x3f
uint8_t ssd1306_oled_vert_shift(uint8_t offset)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_VERT_OFFSET;
    data_buf[2] = offset;
    
    return _i2c_write(data_buf, 3);
}

// default value for clk is 0x80
uint8_t ssd1306_oled_set_clock(uint8_t clk)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_CLK_SET;
    data_buf[2] = clk;
    
    return _i2c_write(data_buf, 3);
}

// default value for precharge is 0xf1
uint8_t ssd1306_oled_set_precharge(uint8_t precharge)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_PRECHARGE;
    data_buf[2] = precharge;
    
    return _i2c_write(data_buf, 3);
}

// default value for deselect is 0x40
uint8_t ssd1306_oled_set_deselect(uint8_t voltage)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_DESELECT_LV;
    data_buf[2] = voltage;
    
    return _i2c_write(data_buf, 3);
}

// default value for com pin is 0x02
uint8_t ssd1306_oled_set_com_pin(uint8_t value)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_COM_PIN;
    data_buf[2] = value;
    
    return _i2c_write(data_buf, 3);
}

// default value use SSD1306_PAGE_MODE
uint8_t ssd1306_oled_set_mem_mode(uint8_t mode)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_MEMORY_MODE;
    data_buf[2] = mode;
    
    return _i2c_write(data_buf, 3);
}

uint8_t ssd1306_oled_set_col(uint8_t start, uint8_t end)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_SET_COL_ADDR;
    data_buf[2] = start;
    data_buf[3] = end;
    
    return _i2c_write(data_buf, 4);
}

uint8_t ssd1306_oled_set_page(uint8_t start, uint8_t end)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_SET_PAGE_ADDR;
    data_buf[2] = start;
    data_buf[3] = end;
    
    return _i2c_write(data_buf, 4);
}

// default contrast value is 0x7f
uint8_t ssd1306_oled_set_constrast(uint8_t value)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_CONTRAST;
    data_buf[2] = value;
    
    return _i2c_write(data_buf, 3);
}

uint8_t ssd1306_oled_scroll_onoff(uint8_t onoff)
{
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    if (onoff == 0)
        data_buf[1] = SSD1306_COMM_DISABLE_SCROLL;
    else
        data_buf[1] = SSD1306_COMM_ENABLE_SCROLL;
    
    return _i2c_write(data_buf, 2);
}

uint8_t ssd1306_oled_set_X(uint8_t x)
{
    if (x >= max_columns)
        return 1;

    global_x = x;
    
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_LOW_COLUMN | (x & 0x0f);
    data_buf[2] = SSD1306_COMM_HIGH_COLUMN | ((x >> 4) & 0x0f);
    
    return _i2c_write(data_buf, 3);
}

uint8_t ssd1306_oled_set_Y(uint8_t y)
{
    if (y >= (max_lines / 8))
        return 1;

    global_y = y;
    
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_PAGE_NUMBER | (y & 0x0f);

    return _i2c_write(data_buf, 2);
}

uint8_t ssd1306_oled_set_XY(uint8_t x, uint8_t y)
{
    if (x >= max_columns || y >= (max_lines / 8))
        return 1;

    global_x = x;
    global_y = y;
    
    data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
    data_buf[1] = SSD1306_COMM_PAGE_NUMBER | (y & 0x0f);

    data_buf[2] = SSD1306_COMM_LOW_COLUMN | (x & 0x0f);
    
    data_buf[3] = SSD1306_COMM_HIGH_COLUMN | ((x >> 4) & 0x0f);
    
    return _i2c_write(data_buf, 4);
}

uint8_t ssd1306_oled_set_rotate(uint8_t degree)
{
    // only degree 0 and 180
    if (degree == 0)
    {
        data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
        data_buf[1] = SSD1306_COMM_HORIZ_FLIP;
        data_buf[2] = SSD1306_COMM_SCAN_REVS;
    
        return _i2c_write(data_buf, 3);
    }
    else if (degree == 180)
    {
        data_buf[0] = SSD1306_COMM_CONTROL_BYTE;
        data_buf[1] = SSD1306_COMM_HORIZ_NORM;
        data_buf[2] = SSD1306_COMM_SCAN_NORM;
    
        return _i2c_write(data_buf, 3);
    }
    else
        return 1;
}

uint8_t ssd1306_oled_default_config(uint8_t oled_lines, uint8_t oled_columns)
{
    if (oled_lines != SSD1306_128_64_LINES && oled_lines != SSD1306_128_32_LINES && SSD1306_64_48_LINES)
        oled_lines = SSD1306_128_64_LINES;
        
    if (oled_columns != SSD1306_128_64_COLUMNS && oled_lines != SSD1306_128_32_COLUMNS && SSD1306_64_48_COLUMNS)
        oled_columns = SSD1306_128_64_COLUMNS;
        
    max_lines = oled_lines;
    max_columns = oled_columns;
    global_x = 0;
    global_y = 0;
    
    if (ssd1306_oled_save_resolution(max_columns, max_lines) != 0)
        return 1;
    
    uint16_t i = 0;
    data_buf[i++] = SSD1306_COMM_CONTROL_BYTE;  //command control byte
    data_buf[i++] = SSD1306_COMM_DISPLAY_OFF;   //display off
    data_buf[i++] = SSD1306_COMM_DISP_NORM;     //Set Normal Display (default)
    data_buf[i++] = SSD1306_COMM_CLK_SET;       //SETDISPLAYCLOCKDIV
    data_buf[i++] = 0x80;                       // the suggested ratio 0x80
    data_buf[i++] = SSD1306_COMM_MULTIPLEX;     //SSD1306_SETMULTIPLEX
    data_buf[i++] = oled_lines - 1;             // height is 32 or 64 (always -1)
    data_buf[i++] = SSD1306_COMM_VERT_OFFSET;   //SETDISPLAYOFFSET
    data_buf[i++] = 0;                          //no offset
    data_buf[i++] = SSD1306_COMM_START_LINE;    //SETSTARTLINE
    data_buf[i++] = SSD1306_COMM_CHARGE_PUMP;   //CHARGEPUMP
    data_buf[i++] = 0x14;                       //turn on charge pump
    data_buf[i++] = SSD1306_COMM_MEMORY_MODE;   //MEMORYMODE
    data_buf[i++] = SSD1306_PAGE_MODE;          // page mode
    data_buf[i++] = SSD1306_COMM_HORIZ_NORM;    //SEGREMAP  Mirror screen horizontally (A0)
    data_buf[i++] = SSD1306_COMM_SCAN_NORM;     //COMSCANDEC Rotate screen vertically (C0)
    data_buf[i++] = SSD1306_COMM_COM_PIN;       //HARDWARE PIN 
    if (oled_lines == 32)
        data_buf[i++] = 0x02;                       // for 32 lines
    else
        data_buf[i++] = 0x12;                       // for 64 lines or 48 lines
    data_buf[i++] = SSD1306_COMM_CONTRAST;      //SETCONTRAST
    data_buf[i++] = 0x7f;                       // default contract value
    data_buf[i++] = SSD1306_COMM_PRECHARGE;     //SETPRECHARGE
    data_buf[i++] = 0xf1;                       // default precharge value
    data_buf[i++] = SSD1306_COMM_DESELECT_LV;   //SETVCOMDETECT                
    data_buf[i++] = 0x40;                       // default deselect value
    data_buf[i++] = SSD1306_COMM_RESUME_RAM;    //DISPLAYALLON_RESUME
    data_buf[i++] = SSD1306_COMM_DISP_NORM;     //NORMALDISPLAY
    data_buf[i++] = SSD1306_COMM_DISPLAY_ON;    //DISPLAY ON             
    data_buf[i++] = SSD1306_COMM_DISABLE_SCROLL;//Stop scroll
    
    return _i2c_write(data_buf, i);
}

uint8_t ssd1306_oled_write_line(uint8_t size, char* ptr)
{
    uint16_t i = 0;
    uint16_t index = 0;
    uint8_t* font_table = 0;
    uint8_t font_table_width = 0;
    
    if (ptr == 0)
        return 1;
    
    if (size == SSD1306_FONT_SMALL) // 5x7
    {
        font_table = (uint8_t*)font5x7;
        font_table_width = 5;
    }
    else if (size == SSD1306_FONT_NORMAL) // 8x8
    {
        font_table = (uint8_t*)font8x8;
        font_table_width = 8;
    }
    else
        return 1;
    
    data_buf[i++] = SSD1306_DATA_CONTROL_BYTE;
    
    // font table range in ascii table is from 0x20(space) to 0x7e(~)
    while (ptr[index] != 0 && i <= 1024)
    {
        if ((ptr[index] < ' ') || (ptr[index] > '~'))
            return 1;

        uint8_t* font_ptr = &font_table[(ptr[index] - 0x20) * font_table_width];
        uint8_t j = 0;
        for (j = 0; j < font_table_width; j++)
        {
            data_buf[i++] = font_ptr[j];
            if (i > 1024)
                return 1;
        }
        // insert 1 col space for small font size)
        if (size == SSD1306_FONT_SMALL)
            data_buf[i++] = 0x00;
        index++;
    }
    
    return _i2c_write(data_buf, i);
}

uint8_t ssd1306_oled_write_string(uint8_t size, char* ptr)
{
    uint8_t rc = 0;
    
    if (ptr == 0)
        return 1;
    
    char* line = 0;
    char* cr = 0;
    char buf[20];
    
    line = ptr;
    do {
        memset(buf, 0, 20);
        cr = strstr(line, "\\n");
        if (cr != NULL)
        {
            strncpy(buf, line, cr - line);
        }
        else
        {
            strcpy(buf, line);
        }
        
        // set cursor position
        ssd1306_oled_set_XY(global_x, global_y);
        rc += ssd1306_oled_write_line(size, buf);
        
        if (cr != NULL)
        {
            line = &cr[2];
            global_x = 0;
            global_y++;
            if (global_y >= (max_lines / 8))
                global_y = 0;
        }
        else
            line = NULL;
                
    }while (line != NULL);
    
    return rc;
}

uint8_t ssd1306_oled_clear_line(uint8_t row)
{
    uint8_t i;
    if (row >= (max_lines / 8))
        return 1;
        
    ssd1306_oled_set_XY(0, row);
    data_buf[0] = SSD1306_DATA_CONTROL_BYTE;
    for (i = 0; i < max_columns; i++)
        data_buf[i+1] = 0x00;
        
    return _i2c_write(data_buf, 1 + max_columns);
}

uint8_t ssd1306_oled_clear_screen()
{
    uint8_t rc = 0;
    uint8_t i;
    
    for (i = 0; i < (max_lines / 8); i++)
    {
        rc += ssd1306_oled_clear_line(i);
    }
    
    return rc;
}

uint8_t ssd1306_oled_save_resolution(uint8_t column, uint8_t row)
{
    FILE* fp;
    
    fp = fopen(init_oled_type_file, "w");
    
    if (fp == NULL)
    {
        // file create failed
        return 1;
    }
    
    fprintf(fp, "%hhux%hhu", column, row);
    fclose(fp);
    
    return 0;
}

uint8_t ssd1306_oled_load_resolution()
{
    FILE* fp;
    
    fp = fopen(init_oled_type_file, "r");
    
    if (fp == NULL)
    {
        // file not exists
        return 1;
    }
    
    // file exists
    fscanf(fp, "%hhux%hhu", &max_columns, &max_lines);
    fclose(fp);
    
    return 0;
}

/home/dengxm2024/linuxProgDir/userside_code/ssd1306-linux-master/ssd1306.h

#ifndef __SSD1306_H__
#define __SSD1306_H__

#define SSD1306_I2C_ADDR            0x3c

#define SSD1306_COMM_CONTROL_BYTE   0x00
#define SSD1306_DATA_CONTROL_BYTE   0x40

#define SSD1306_COMM_DISPLAY_OFF    0xae
#define SSD1306_COMM_DISPLAY_ON     0xaf
#define SSD1306_COMM_HORIZ_NORM     0xa0
#define SSD1306_COMM_HORIZ_FLIP     0xa1
#define SSD1306_COMM_RESUME_RAM     0xa4
#define SSD1306_COMM_IGNORE_RAM     0xa5
#define SSD1306_COMM_DISP_NORM      0xa6
#define SSD1306_COMM_DISP_INVERSE   0xa7
#define SSD1306_COMM_MULTIPLEX      0xa8
#define SSD1306_COMM_VERT_OFFSET    0xd3
#define SSD1306_COMM_CLK_SET        0xd5
#define SSD1306_COMM_PRECHARGE      0xd9
#define SSD1306_COMM_COM_PIN        0xda
#define SSD1306_COMM_DESELECT_LV    0xdb
#define SSD1306_COMM_CONTRAST       0x81
#define SSD1306_COMM_DISABLE_SCROLL 0x2e
#define SSD1306_COMM_ENABLE_SCROLL  0x2f
#define SSD1306_COMM_PAGE_NUMBER    0xb0
#define SSD1306_COMM_LOW_COLUMN     0x00
#define SSD1306_COMM_HIGH_COLUMN    0x10

#define SSD1306_COMM_START_LINE     0x40

#define SSD1306_COMM_CHARGE_PUMP    0x8d

#define SSD1306_COMM_SCAN_NORM      0xc0
#define SSD1306_COMM_SCAN_REVS      0xc8

#define SSD1306_COMM_MEMORY_MODE    0x20
#define SSD1306_COMM_SET_COL_ADDR   0x21
#define SSD1306_COMM_SET_PAGE_ADDR  0x22

#define SSD1306_HORI_MODE           0x00
#define SSD1306_VERT_MODE           0x01
#define SSD1306_PAGE_MODE           0x02

#define SSD1306_FONT_SMALL          0x00
#define SSD1306_FONT_NORMAL         0x01

#define SSD1306_128_64_LINES        64
#define SSD1306_128_32_LINES        32
#define SSD1306_64_48_LINES         48

#define SSD1306_128_64_COLUMNS      128
#define SSD1306_128_32_COLUMNS      128
#define SSD1306_64_48_COLUMNS       64


uint8_t ssd1306_init(uint8_t i2c_dev);
uint8_t ssd1306_end();
uint8_t ssd1306_oled_onoff(uint8_t onoff);
uint8_t ssd1306_oled_horizontal_flip(uint8_t flip);
uint8_t ssd1306_oled_display_flip(uint8_t flip);
uint8_t ssd1306_oled_multiplex(uint8_t row);
uint8_t ssd1306_oled_vert_shift(uint8_t offset);
uint8_t ssd1306_oled_set_clock(uint8_t clk);
uint8_t ssd1306_oled_set_precharge(uint8_t precharge);
uint8_t ssd1306_oled_set_deselect(uint8_t voltage);
uint8_t ssd1306_oled_set_com_pin(uint8_t value);
uint8_t ssd1306_oled_set_mem_mode(uint8_t mode);
uint8_t ssd1306_oled_set_col(uint8_t start, uint8_t end);
uint8_t ssd1306_oled_set_page(uint8_t start, uint8_t end);
uint8_t ssd1306_oled_set_constrast(uint8_t value);
uint8_t ssd1306_oled_scroll_onoff(uint8_t onoff);
uint8_t ssd1306_oled_set_X(uint8_t x);
uint8_t ssd1306_oled_set_Y(uint8_t y);
uint8_t ssd1306_oled_set_XY(uint8_t x, uint8_t y);
uint8_t ssd1306_oled_set_rotate(uint8_t degree);
uint8_t ssd1306_oled_default_config(uint8_t oled_lines, uint8_t oled_columns);
uint8_t ssd1306_oled_write_line(uint8_t size, char* ptr);
uint8_t ssd1306_oled_write_string(uint8_t size, char* ptr);
uint8_t ssd1306_oled_clear_line(uint8_t row);
uint8_t ssd1306_oled_clear_screen();
uint8_t ssd1306_oled_save_resolution(uint8_t column, uint8_t row);
uint8_t ssd1306_oled_load_resolution();

#endif

/home/dengxm2024/linuxProgDir/userside_code/ssd1306-linux-master/font.h

 

#ifndef __FONT_H
#define __FONT_H

#include <stdint.h>
#include <inttypes.h>

const uint8_t font5x7[] = {
  0x00, 0x00, 0x00, 0x00, 0x00, // SPACE
  0x00, 0x00, 0x5F, 0x00, 0x00, // !
  0x00, 0x03, 0x00, 0x03, 0x00, // "
  0x14, 0x3E, 0x14, 0x3E, 0x14, // #
  0x24, 0x2A, 0x7F, 0x2A, 0x12, // $
  0x43, 0x33, 0x08, 0x66, 0x61, // %
  0x36, 0x49, 0x55, 0x22, 0x50, // &
  0x00, 0x05, 0x03, 0x00, 0x00, // '
  0x00, 0x1C, 0x22, 0x41, 0x00, // (
  0x00, 0x41, 0x22, 0x1C, 0x00, // )
  0x14, 0x08, 0x3E, 0x08, 0x14, // *
  0x08, 0x08, 0x3E, 0x08, 0x08, // +
  0x00, 0x50, 0x30, 0x00, 0x00, // ,
  0x08, 0x08, 0x08, 0x08, 0x08, // -
  0x00, 0x60, 0x60, 0x00, 0x00, // .
  0x20, 0x10, 0x08, 0x04, 0x02, // /

  0x3E, 0x51, 0x49, 0x45, 0x3E, // 0
  0x00, 0x04, 0x02, 0x7F, 0x00, // 1
  0x42, 0x61, 0x51, 0x49, 0x46, // 2
  0x22, 0x41, 0x49, 0x49, 0x36, // 3
  0x18, 0x14, 0x12, 0x7F, 0x10, // 4
  0x27, 0x45, 0x45, 0x45, 0x39, // 5
  0x3E, 0x49, 0x49, 0x49, 0x32, // 6
  0x01, 0x01, 0x71, 0x09, 0x07, // 7
  0x36, 0x49, 0x49, 0x49, 0x36, // 8
  0x26, 0x49, 0x49, 0x49, 0x3E, // 9
  0x00, 0x36, 0x36, 0x00, 0x00, // :
  0x00, 0x56, 0x36, 0x00, 0x00, // ;
  0x08, 0x14, 0x22, 0x41, 0x00, // <
  0x14, 0x14, 0x14, 0x14, 0x14, // =
  0x00, 0x41, 0x22, 0x14, 0x08, // >
  0x02, 0x01, 0x51, 0x09, 0x06, // ?

  0x3E, 0x41, 0x59, 0x55, 0x5E, // @
  0x7E, 0x09, 0x09, 0x09, 0x7E, // A
  0x7F, 0x49, 0x49, 0x49, 0x36, // B
  0x3E, 0x41, 0x41, 0x41, 0x22, // C
  0x7F, 0x41, 0x41, 0x41, 0x3E, // D
  0x7F, 0x49, 0x49, 0x49, 0x41, // E
  0x7F, 0x09, 0x09, 0x09, 0x01, // F
  0x3E, 0x41, 0x41, 0x49, 0x3A, // G
  0x7F, 0x08, 0x08, 0x08, 0x7F, // H
  0x00, 0x41, 0x7F, 0x41, 0x00, // I
  0x30, 0x40, 0x40, 0x40, 0x3F, // J
  0x7F, 0x08, 0x14, 0x22, 0x41, // K
  0x7F, 0x40, 0x40, 0x40, 0x40, // L
  0x7F, 0x02, 0x0C, 0x02, 0x7F, // M
  0x7F, 0x02, 0x04, 0x08, 0x7F, // N
  0x3E, 0x41, 0x41, 0x41, 0x3E, // O

  0x7F, 0x09, 0x09, 0x09, 0x06, // P
  0x1E, 0x21, 0x21, 0x21, 0x5E, // Q
  0x7F, 0x09, 0x09, 0x09, 0x76, // R
  0x26, 0x49, 0x49, 0x49, 0x32, // S
  0x01, 0x01, 0x7F, 0x01, 0x01, // T
  0x3F, 0x40, 0x40, 0x40, 0x3F, // U
  0x1F, 0x20, 0x40, 0x20, 0x1F, // V
  0x7F, 0x20, 0x10, 0x20, 0x7F, // W
  0x41, 0x22, 0x1C, 0x22, 0x41, // X
  0x07, 0x08, 0x70, 0x08, 0x07, // Y
  0x61, 0x51, 0x49, 0x45, 0x43, // Z
  0x00, 0x7F, 0x41, 0x00, 0x00, // [
  0x02, 0x04, 0x08, 0x10, 0x20, // backslash
  0x00, 0x00, 0x41, 0x7F, 0x00, // ]
  0x04, 0x02, 0x01, 0x02, 0x04, // ^
  0x40, 0x40, 0x40, 0x40, 0x40, // _

  0x00, 0x01, 0x02, 0x04, 0x00, // `
  0x20, 0x54, 0x54, 0x54, 0x78, // a
  0x7F, 0x44, 0x44, 0x44, 0x38, // b
  0x38, 0x44, 0x44, 0x44, 0x44, // c
  0x38, 0x44, 0x44, 0x44, 0x7F, // d
  0x38, 0x54, 0x54, 0x54, 0x18, // e
  0x04, 0x04, 0x7E, 0x05, 0x05, // f
  0x08, 0x54, 0x54, 0x54, 0x3C, // g
  0x7F, 0x08, 0x04, 0x04, 0x78, // h
  0x00, 0x44, 0x7D, 0x40, 0x00, // i
  0x20, 0x40, 0x44, 0x3D, 0x00, // j
  0x7F, 0x10, 0x28, 0x44, 0x00, // k
  0x00, 0x41, 0x7F, 0x40, 0x00, // l
  0x7C, 0x04, 0x78, 0x04, 0x78, // m
  0x7C, 0x08, 0x04, 0x04, 0x78, // n
  0x38, 0x44, 0x44, 0x44, 0x38, // o

  0x7C, 0x14, 0x14, 0x14, 0x08, // p
  0x08, 0x14, 0x14, 0x14, 0x7C, // q
  0x00, 0x7C, 0x08, 0x04, 0x04, // r
  0x48, 0x54, 0x54, 0x54, 0x20, // s
  0x04, 0x04, 0x3F, 0x44, 0x44, // t
  0x3C, 0x40, 0x40, 0x20, 0x7C, // u
  0x1C, 0x20, 0x40, 0x20, 0x1C, // v
  0x3C, 0x40, 0x30, 0x40, 0x3C, // w
  0x44, 0x28, 0x10, 0x28, 0x44, // x
  0x0C, 0x50, 0x50, 0x50, 0x3C, // y
  0x44, 0x64, 0x54, 0x4C, 0x44, // z
  0x00, 0x08, 0x36, 0x41, 0x41, // {
  0x00, 0x00, 0x7F, 0x00, 0x00, // |
  0x41, 0x41, 0x36, 0x08, 0x00, // }
  0x02, 0x01, 0x02, 0x04, 0x02  // ~
};

const uint8_t font8x8[] = {
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  // <space>
  0x00,0x00,0x00,0x00,0x5F,0x00,0x00,0x00,  // !
  0x00,0x00,0x00,0x03,0x00,0x03,0x00,0x00,  // "
  0x00,0x24,0x7E,0x24,0x24,0x7E,0x24,0x00,  // #
  0x00,0x2E,0x2A,0x7F,0x2A,0x3A,0x00,0x00,  // $
  0x00,0x46,0x26,0x10,0x08,0x64,0x62,0x00,  // %
  0x00,0x20,0x54,0x4A,0x54,0x20,0x50,0x00,  // &
  0x00,0x00,0x00,0x04,0x02,0x00,0x00,0x00,  // '
  0x00,0x00,0x00,0x3C,0x42,0x00,0x00,0x00,  // (
  0x00,0x00,0x00,0x42,0x3C,0x00,0x00,0x00,  // )
  0x00,0x10,0x54,0x38,0x54,0x10,0x00,0x00,  // *
  0x00,0x10,0x10,0x7C,0x10,0x10,0x00,0x00,  // +
  0x00,0x00,0x00,0x80,0x60,0x00,0x00,0x00,  // ,
  0x00,0x10,0x10,0x10,0x10,0x10,0x00,0x00,  // -
  0x00,0x00,0x00,0x60,0x60,0x00,0x00,0x00,  // .
  0x00,0x40,0x20,0x10,0x08,0x04,0x00,0x00,  // /

  0x3C,0x62,0x52,0x4A,0x46,0x3C,0x00,0x00,  // 0
  0x44,0x42,0x7E,0x40,0x40,0x00,0x00,0x00,  // 1
  0x64,0x52,0x52,0x52,0x52,0x4C,0x00,0x00,  // 2
  0x24,0x42,0x42,0x4A,0x4A,0x34,0x00,0x00,  // 3
  0x30,0x28,0x24,0x7E,0x20,0x20,0x00,0x00,  // 4
  0x2E,0x4A,0x4A,0x4A,0x4A,0x32,0x00,0x00,  // 5
  0x3C,0x4A,0x4A,0x4A,0x4A,0x30,0x00,0x00,  // 6
  0x02,0x02,0x62,0x12,0x0A,0x06,0x00,0x00,  // 7
  0x34,0x4A,0x4A,0x4A,0x4A,0x34,0x00,0x00,  // 8
  0x0C,0x52,0x52,0x52,0x52,0x3C,0x00,0x00,  // 9
  0x00,0x00,0x00,0x48,0x00,0x00,0x00,0x00,  // :
  0x00,0x00,0x80,0x64,0x00,0x00,0x00,0x00,  // ;
  0x00,0x00,0x10,0x28,0x44,0x00,0x00,0x00,  // <
  0x00,0x28,0x28,0x28,0x28,0x28,0x00,0x00,  // =
  0x00,0x00,0x44,0x28,0x10,0x00,0x00,0x00,  // >
  0x00,0x04,0x02,0x02,0x52,0x0A,0x04,0x00,  // ?

  0x00,0x3C,0x42,0x5A,0x56,0x5A,0x1C,0x00,  // @
  0x7C,0x12,0x12,0x12,0x12,0x7C,0x00,0x00,  // A
  0x7E,0x4A,0x4A,0x4A,0x4A,0x34,0x00,0x00,  // B
  0x3C,0x42,0x42,0x42,0x42,0x24,0x00,0x00,  // C
  0x7E,0x42,0x42,0x42,0x24,0x18,0x00,0x00,  // D
  0x7E,0x4A,0x4A,0x4A,0x4A,0x42,0x00,0x00,  // E
  0x7E,0x0A,0x0A,0x0A,0x0A,0x02,0x00,0x00,  // F
  0x3C,0x42,0x42,0x52,0x52,0x34,0x00,0x00,  // G
  0x7E,0x08,0x08,0x08,0x08,0x7E,0x00,0x00,  // H
  0x00,0x42,0x42,0x7E,0x42,0x42,0x00,0x00,  // I
  0x30,0x40,0x40,0x40,0x40,0x3E,0x00,0x00,  // J
  0x7E,0x08,0x08,0x14,0x22,0x40,0x00,0x00,  // K
  0x7E,0x40,0x40,0x40,0x40,0x40,0x00,0x00,  // L
  0x7E,0x04,0x08,0x08,0x04,0x7E,0x00,0x00,  // M
  0x7E,0x04,0x08,0x10,0x20,0x7E,0x00,0x00,  // N
  0x3C,0x42,0x42,0x42,0x42,0x3C,0x00,0x00,  // O

  0x7E,0x12,0x12,0x12,0x12,0x0C,0x00,0x00,  // P
  0x3C,0x42,0x52,0x62,0x42,0x3C,0x00,0x00,  // Q
  0x7E,0x12,0x12,0x12,0x32,0x4C,0x00,0x00,  // R
  0x24,0x4A,0x4A,0x4A,0x4A,0x30,0x00,0x00,  // S
  0x02,0x02,0x02,0x7E,0x02,0x02,0x02,0x00,  // T
  0x3E,0x40,0x40,0x40,0x40,0x3E,0x00,0x00,  // U
  0x1E,0x20,0x40,0x40,0x20,0x1E,0x00,0x00,  // V
  0x3E,0x40,0x20,0x20,0x40,0x3E,0x00,0x00,  // W
  0x42,0x24,0x18,0x18,0x24,0x42,0x00,0x00,  // X
  0x02,0x04,0x08,0x70,0x08,0x04,0x02,0x00,  // Y
  0x42,0x62,0x52,0x4A,0x46,0x42,0x00,0x00,  // Z
  0x00,0x00,0x7E,0x42,0x42,0x00,0x00,0x00,  // [
  0x00,0x04,0x08,0x10,0x20,0x40,0x00,0x00,  // <backslash>
  0x00,0x00,0x42,0x42,0x7E,0x00,0x00,0x00,  // ]
  0x00,0x08,0x04,0x7E,0x04,0x08,0x00,0x00,  // ^
  0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x00,  // _

  0x3C,0x42,0x99,0xA5,0xA5,0x81,0x42,0x3C,  // `
  0x00,0x20,0x54,0x54,0x54,0x78,0x00,0x00,  // a
  0x00,0x7E,0x48,0x48,0x48,0x30,0x00,0x00,  // b
  0x00,0x00,0x38,0x44,0x44,0x44,0x00,0x00,  // c
  0x00,0x30,0x48,0x48,0x48,0x7E,0x00,0x00,  // d
  0x00,0x38,0x54,0x54,0x54,0x48,0x00,0x00,  // e
  0x00,0x00,0x00,0x7C,0x0A,0x02,0x00,0x00,  // f
  0x00,0x18,0xA4,0xA4,0xA4,0xA4,0x7C,0x00,  // g
  0x00,0x7E,0x08,0x08,0x08,0x70,0x00,0x00,  // h
  0x00,0x00,0x00,0x48,0x7A,0x40,0x00,0x00,  // i
  0x00,0x00,0x40,0x80,0x80,0x7A,0x00,0x00,  // j
  0x00,0x7E,0x18,0x24,0x40,0x00,0x00,0x00,  // k
  0x00,0x00,0x00,0x3E,0x40,0x40,0x00,0x00,  // l
  0x00,0x7C,0x04,0x78,0x04,0x78,0x00,0x00,  // m
  0x00,0x7C,0x04,0x04,0x04,0x78,0x00,0x00,  // n
  0x00,0x38,0x44,0x44,0x44,0x38,0x00,0x00,  // o

  0x00,0xFC,0x24,0x24,0x24,0x18,0x00,0x00,  // p
  0x00,0x18,0x24,0x24,0x24,0xFC,0x80,0x00,  // q
  0x00,0x00,0x78,0x04,0x04,0x04,0x00,0x00,  // r
  0x00,0x48,0x54,0x54,0x54,0x20,0x00,0x00,  // s
  0x00,0x00,0x04,0x3E,0x44,0x40,0x00,0x00,  // t
  0x00,0x3C,0x40,0x40,0x40,0x3C,0x00,0x00,  // u
  0x00,0x0C,0x30,0x40,0x30,0x0C,0x00,0x00,  // v
  0x00,0x3C,0x40,0x38,0x40,0x3C,0x00,0x00,  // w
  0x00,0x44,0x28,0x10,0x28,0x44,0x00,0x00,  // x
  0x00,0x1C,0xA0,0xA0,0xA0,0x7C,0x00,0x00,  // y
  0x00,0x44,0x64,0x54,0x4C,0x44,0x00,0x00,  // z
  0x00,0x08,0x08,0x76,0x42,0x42,0x00,0x00,  // {
  0x00,0x00,0x00,0x7E,0x00,0x00,0x00,0x00,  // |
  0x00,0x42,0x42,0x76,0x08,0x08,0x00,0x00,  // }
  0x00,0x00,0x04,0x02,0x04,0x02,0x00,0x00   // ~  
};

#endif

 /home/dengxm2024/linuxProgDir/userside_code/ssd1306-linux-master/Makefile

#CROSS_COMPILE是环境变量，是交叉编译工具的前缀，隐式声明编译器
CC = $(CROSS_COMPILE)gcc
CXX = $(CROSS_COMPILE)g++

#显示声明编译器
#CC = arm-fsl-linux-gnueabi-gcc
#CXX = arm-fsl-linux-gnueabi-g++

CXXFLAGS = -Wall -g
CFLAGS=-I ./ -Wall -Werror
LDFLAGS=-static
OBJS=main.o ssd1306.o linux_i2c.o
BIN=ssd1306_bin

default: $(BIN)
.PHONY: default clean

# Adapted from scottmcpeak.com/autodepend/autodepend.html
-include $(OBJS:.o=.d)
%.o: %.c
	$(CC) -c $(CFLAGS) $< -o $*.o
	$(CC) -MM $(CFLAGS) $< > $*.d
	@cp -f $*.d $*.d.tmp
	@sed -e 's/.*://' -e 's/\\$$//' < $*.d.tmp | fmt -1 | \
	  sed -e 's/^ *//' -e 's/$$/:/' >> $*.d
	@rm -f $*.d.tmp

$(BIN):$(OBJS)
	$(CC) $(CFLAGS) -o $@ $(OBJS) $(LDFLAGS)

clean:
	rm -f *.o *.d $(BIN)

编译：

dengxm2024@PC-202105142413:~/linuxProgDir/userside_code/ssd1306-linux-master$ make
arm-fsl-linux-gnueabi-gcc -c -I ./ -Wall -Werror main.c -o main.o
arm-fsl-linux-gnueabi-gcc -MM -I ./ -Wall -Werror main.c > main.d
arm-fsl-linux-gnueabi-gcc -c -I ./ -Wall -Werror ssd1306.c -o ssd1306.o
arm-fsl-linux-gnueabi-gcc -MM -I ./ -Wall -Werror ssd1306.c > ssd1306.d
arm-fsl-linux-gnueabi-gcc -c -I ./ -Wall -Werror linux_i2c.c -o linux_i2c.o
arm-fsl-linux-gnueabi-gcc -MM -I ./ -Wall -Werror linux_i2c.c > linux_i2c.d
arm-fsl-linux-gnueabi-gcc -I ./ -Wall -Werror -o ssd1306_bin main.o ssd1306.o linux_i2c.o -static

复制结果到web服务器：

cp ssd1306_bin /mnt/d/imx280a_exe_folder/

转到开发板终端窗口：

root@EasyARM-iMX28x ~# wget http://192.168.0.233:443/imx280a_exe_folder/ssd1306_
bin
Connecting to 192.168.0.233:443 (192.168.0.233:443)
ssd1306_bin          100% |*******************************|   601k  0:00:00 ETA
root@EasyARM-iMX28x ~# ls
Digit_Display      g_file_storage.ko  i2c_ds2460_test    ssd1306_bin
bcmdhd.ko          gpio_driver.ko     lradc.ko           start_qt
beep.ko            hello              qt_hellow          up_wifi_module
beep_test          helloworld         qt_hellow_zh       usb_storage_up
root@EasyARM-iMX28x ~# ls -a -l
drwxr-xr-x    3 1004     root          1504 Jan  1 00:02 .
drwxr-xr-x   19 root     root          1328 Jan  1  1970 ..
-rw-------    1 root     root          1180 Jan  1 00:02 .ash_history
-rw-r--r--    1 1004     root           305 Jan  1 00:00 .kobs
drwxr-xr-x    3 1004     root           224 Jan  1 00:00 .qws
-rwxr-xr-x    1 root     root         10852 Jan  1  1970 Digit_Display
-rw-r--r--    1 1004     root        411491 Jan  1 00:00 bcmdhd.ko
-rw-r--r--    1 1004     root          4275 Jan  1 00:00 beep.ko
-rwxr-xr-x    1 1004     root          5540 Jan  1 00:00 beep_test
-rw-r--r--    1 1004     root         37874 Jan  1 00:00 g_file_storage.ko
-rw-r--r--    1 1004     root          9554 Jan  1 00:00 gpio_driver.ko
-rwxr-xr-x    1 1004     root          5520 Jan  1 00:00 hello
-rwxr-xr-x    1 root     root          8961 Jan  1  1970 helloworld
-rwxr-xr-x    1 1004     root          8065 Jan  1 00:00 i2c_ds2460_test
-rwxr-xr-x    1 1004     root          4778 Jan  1 00:00 lradc.ko
-rwxr-xr-x    1 1004     root          8317 Jan  1 00:00 qt_hellow
-rwxr-xr-x    1 1004     root          8502 Jan  1 00:00 qt_hellow_zh
-rw-r--r--    1 root     root        616400 Jan  1 00:02 ssd1306_bin
-rwxr-xr-x    1 1004     root          1239 Jan  1 00:00 start_qt
-rwxr-xr-x    1 1004     root           147 Jan  1 00:00 up_wifi_module
-rwxr-xr-x    1 1004     root           121 Jan  1 00:00 usb_storage_up
root@EasyARM-iMX28x ~# chmod +x ssd1306_bin 

运行：

root@EasyARM-iMX28x ~# ./ssd1306_bin -I 128x64
root@EasyARM-iMX28x ~# ./ssd1306_bin -c
root@EasyARM-iMX28x ~# ./ssd1306_bin -l "Hello World"
root@EasyARM-iMX28x ~# ./ssd1306_bin -c
root@EasyARM-iMX28x ~# ./ssd1306_bin -c
root@EasyARM-iMX28x ~# ./ssd1306_bin -l "Hello World"
root@EasyARM-iMX28x ~# ./ssd1306_bin -m "alpha\nbravo\ncharlie\ndelta"
root@EasyARM-iMX28x ~# ./ssd1306_bin -r 180
root@EasyARM-iMX28x ~# ./ssd1306_bin -c
root@EasyARM-iMX28x ~# ./ssd1306_bin -l "Hello World"
root@EasyARM-iMX28x ~# ./ssd1306_bin -r 0

运行帮助：

OLED SSD1306 Linux驱动程序

这是使用linux I2C设备节点的纯c代码（/dev/i2c-X X表示0、1、2、3...）。请确保linux已经运行“modprobe i2c-dev”。128x64和128x32仅支持和使用I2C接口

文件夹

linux_i2c.c源代码，用于linux设备节点中的i2c控制。linux_i2c.h 头文件，用于 linux 中的 i2c 控制。ssd1306.c i2c协议函数用于控制oled SSD1306。ssd1306.h头文件，用于SSD1306中的i2c协议函数和定义命令。font.h字体头文件定义了5x7小字体和8x8正常字体。ASCII码值从0x20（空格）到0x7e（~）。main.c主文件，用于获取参数并控制oled SSD1306。Makefile plain Makefile，用于构建源代码。它在树莓派上运行。Readme.md 这个自述文件。

如何编译

需要make和gcc。如果您使用交叉编译，请自定义 $(CC)。键入“make”以构建二进制文件“ssd1306_bin”。键入“make clean”以清理项目。

如何使用

每次上电时，请务必将oled模块初始化一次。 如果不使用默认值 /dev/i2c-0，则每次设置设备节点地址 init oled 模块始终将 XY 光标重置为 (0,0) 所有参数可以一起设置 如果需要写新文本，清除屏幕，否则会出现措辞重叠的情况 存储在/tmp/.ssd1306_oled_type中的分辨率值，格式为“128x64”或“128x32”或“64x48” 总是先进行显示旋转，然后再填充文本。否则文本将导致镜像 打印文本前，确保XY光标设置在正确位置

参数

-I		初始化 oled (128x32 或 128x64 或 64x48)
-c		清屏 (行号  或 全部)
-d		0/关显示 1/开显示
-f      0/小字体 5x7 1/正常字体 8x8 (缺省小字体)
-h		帮助
-i		0/正常显示 1/反显示
-l		画一条线
-m		显示字符串
-n      I2C 设备地址 (0,1,2..., 缺省 0)
-r		0/不旋转 180/旋转180度
-x		x 位置
-y 		y 位置

示例

初始化OLED一次

  • 分辨率 128x64
$ ./ssd1306_bin -I 128x64
  • 分辨率 128x32
$ ./ssd1306_bin -I 128x32
  • 分辨率 64x48
$ ./ssd1306_bin -I 64x48

清屏

  • 清除第一行
./ssd1306_bin -c0
  • 清除第二行
$ ./ssd1306_bin -c1
  • 清除第四行
$ ./ssd1306_bin -c3
  • 清除整个屏幕
$ ./ssd1306_bin -c

显示 开/关

  • 熄屏
$ ./ssd1306_bin -d 0
  • 亮屏
$ ./ssd1306_bin -d 1

反显

  • 正常显示 (0 是正常显示, 1 反显)
$ ./ssd1306_bin -i 0
  • 反显 (0 是正常显示, 1 反显)
$ ./ssd1306_bin -i 1

打印字符串

  • 打印一行 "Hello World"
$ ./ssd1306_bin -l "Hello World"
  • 显示信息 "alpha\nbravo\ncharlie\ndelta" (换行请放置 “\n” )
$ ./ssd1306_bin -m "alpha\nbravo\ncharlie\ndelta"

I2C 设备地址 (缺省 /dev/i2c-0)

  • 使用 /dev/i2c-1
$ ./ssd1306_bin -n 1

旋转显示

  • 正常不旋转
$ ./ssd1306_bin -r 0
  • 旋转180度
$ ./ssd1306_bin -r 180

设置光标位置

  • 设置光标的坐标 8,1(x列, 第8列 , y行, 第二行)
$ ./ssd1306_bin -x 8 -y 1

显示效果：

实际上这块显示屏是132X64的点阵，驱动程序还得完善以下，但是已经够用了。

 

brightsm
关注
一、致远电子EasyARM-i.MX287A——初次上电和串口连接
小崔的博客
03-03 4247
一、致远电子EasyARM-i.MX287A——初次上电和串口通讯 Target Board为致远电子EasyARM-i.MX287A开发板 Host Machine为Ubuntu-14.04.5-Desktop-amd64虚拟机 虚拟机软件为VMware Workstation10.0.1 1. 拿到板子初次上电 首先连接LCD屏幕和Target Board...
EasyARM-i.MX280A原理图.pdf
09-14
嵌入式 单片机 NXP 原理图 设计文件
EasyARM-i.MX280A—Linux系统开发板（开发日记2-配置编译环境）
06-24 767
虚拟机Ubuntu编译环境配置： 下载Vim:sudo apt-get install vim 下载SSH:sudo apt-get install openssh-server 下载net-tools:sudo apt-get install net-tools 下载交叉编译器：（arm-none-linux-gnueabi-gcc） wget http://www.codesourcery.com/sgpp/lite/arm/portal/package4571/public/arm-none-lin
EasyArm-i.mx280a开发板入门-升级uboot、内核、根文件系统、交叉编译器
最新发布
brightsm的专栏
08-12 1549
编译uboot出现下面错误 HOSTCC tools/pbl_crc32.o ../tools/mxsimage.c:18:10: fatal error: openssl/evp.h: No such file or directory 18 | #include <openssl/evp.h> | ^~~~~~~~~~~~~~~ compilation terminated.这通常意味着你的主机系统上没有安装 OpenSSL 开发库，或者编译环境没有正确配置来查找 OpenSSL 的头文件。
EasyARM-i.MX280A—Linux系统开发板（开发日记1-登录开发板）
06-14 1103
今天，心仪的板子终于到了，作为一个外行来说，既有对板子开发的期待，又有对自己技术的担忧。为了记录一下自己的开发过程，同时也是自己的成长过程，特地开了个专栏，我知道这将是一个漫长的过程，我会不断的更新，同时也给自己一句励志铭：青春不负，韶华不锈，岁月不欺
I.MX280a的NFS挂载
qian_123456的专栏
04-17 607
nfs 安装(1) apt-get install nfs-kernel-server apt-get install portmap nfs-common (2) 编辑/etc/exports /nfsroot  *(rw,sync,no_root_squash) (3) 修改挂载点的属性 chmod 777 /nfsroot (4) 重启nfs sudo /etc/ini
EasyARM-i.MX280A 硬件使用手册 V1.011
08-03
EasyARM-i.MX280A硬件使用手册V1.011是广州周立功单片机和广州致远电子联合发布的针对EasyARM-i.MX280A开发平台的详尽指南。该手册旨在提供硬件电路设计、接口定义、使用方法以及外围电路设计的指导，帮助用户更好地...
EasyARM-i.MX280A开发平台硬件手册：电路、接口与设计指导
本文档是广州致远电子股份有限公司为用户提供的一款基于i.MX280A处理器的开发平台——EasyARM-i.MX280A的硬件使用手册，旨在详细介绍该开发板的硬件设计、接口定义、使用方法以及外围电路的设计指导。 1. EasyARM-i...
EasyArm_IMX280A_跟文件系统制作1
08-03
"EasyArm_IMX280A_跟文件系统制作1" EasyArm_IMX280A_跟文件系统制作1 是基于 Buildroot 项目的文件系统制作流程，主要用于生成适用于 IMX280A 板卡的文件系统镜像。下面是相关知识点的总结： 1. Buildroot 项目...
【EasyARM-i.MX280A】【UBOOT】环境变量记录
wakojosin的博客
05-17 1011
EasyARM-i.MX280A uboot 环境变量记录
EasyArm_IMX280A_SD卡启动引导1
08-03
前言本教程主要用于指导大家制作可引导的SD卡,从SD卡启动easyarm_imx280a开发板,并挂载rootfs文件系统.交流学习请联系: whjwnavy@
EasyARM-iMX28xx Linux开发指南
01-15
EasyARM-iMX280A 开发指南 基于 EasyARM-i.MX280A/283A/287A 开发套件
imx287 linux+uboot移植
10-30
本文件里包含uboot和linux的移植过程文档和具体源码，内容是参照周立功的官方源码修改的，所以分值不高，有需要自行下载，遇到问题可以跟我交流1002337604@qq.com
linux kernel 4.6 移植到imx280手札
yang_89的专栏
06-12 2959
资源简介 周立功过节发招，49元买了imx280核心板： ARM926EJ-S 架构 arm v5TE 指令集，cpu最高能跑450M 默认光盘资料是 比较老的uboot-2009加linux-2.6内核。 因为本人电脑是ubuntu环境，周立功提供的烧写环境都不适用与我的电脑。 不过众里寻他千百度，终于在开源项目rockbox里面找到一个linux下面的usb烧写工具. 外加一根串口
imx280学习之Uboot移植
ffzwadd的博客
04-23 6714
最近有两个网关项目打算用飞思卡尔imx280的方案，因此买了周立功的EasyARM-imx280A开发板进行一些调研。拿到板子之后发现Uboot是2009的，内核是2.6.35的，都是比较老的版本了。网上查了一下，移植新版Uboot与kernel的移植教程寥寥无几，好不容易google到几个也是一笔带过，都没细说移植过程终于到的一些具体问题以及解决办法。可能高手都惜墨如金吧，像我这种菜鸟就不讲究那
编译Uboot——错误记录
abbywu1225的博客
08-23 915
我使用的是ZLG的EasyARM i.MX280A的开发板。官方提供的编译器时arm-fsl-linux-gnueabihf（gcc 4.4.4）。自己尝试使用arm-linaro-linux-gnueabihf（gcc 4.7.3）。 按照开发手册的流程，解决编译上的报错后，得到imx_ivt_uboot.sb文件。 使用官方提供的工具格式化NAND flash，格式化成功，串口终...
imx280调试串口转换成普通串口的方法
zhangyuchun1234的博客
06-02 1109
调试串口转换成普通串口
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值