NUC980 運行 RT-Thread 驅動 SPI 接口 OLED 播放 badapple

badapple 是什么，上網隨便查了下，沒看出個究竟，不過有個關於這個挺火的標簽或者主題 《 有屏幕的地方就有 badapple 》，網上有很多人用很多方式播放 badapple 動畫，有用單片機在 OLED、LCD、LED點陣播放，有在 PC 上用各種編程語言、以各種形式播放，還有在示波器上播放。我之前也玩過

• 玩轉stm32mp15X 在Uboot中播放badapple，群魔共舞

• bad apple esp32

• STM32 Bad apple

我用到的 badapple 數據是從這里 OLED-STM32 找到的，在這里，badapple 動畫數據被做成了一個二進制文件，因為是在一個 128 X64 的OLED上播放，badapple 數據被做成了一幀是128 X 64 個點的單色位圖形式，可以直接寫入 OLED上顯示，看了下這個文件：

有 5.13 M byte，一幀是 128 X 64 / 8 = 1024 字節的話，就有 5383168 /1024 = 5257 幀了。

用單片機來播放，單片機內部 Flash 一般都比較小，無法把 badapple 數據放入單片機自帶的 Flash 中，所以用單片機播放的話，大概就 2 種思路：

• 把 badapple 放到外部存儲，如 SPI Flash、SD 卡等，單片機從這些存儲設備讀出數據，然后顯示到顯示器上，
• PC 或者 手機 等把 badapple 數據通過通訊接口傳送給 MCU，通訊接口可以是UART、USB、網絡、藍牙等，單片機從這些通訊接口接收到數據然后顯示到顯示器上

這里嘗試把 badapple 數據編譯進 nuc980 固件中，這樣的話，編譯出來的固件至少 5.13 M字節，對於只能用內部flash存儲固件的單片機來說的話，應該是不行的，我還沒見到過內部flash有這么大的單片機。對於 NUC980 可以用外部flash、有這么大的 DRAM，是完全可以實現的，就像之前說的，為所欲為了，如果 NUC980 跑 Linux 的話，這5點幾兆算小了。

這里要做的有：

• 先把顯示器驅動起來，
• 解決怎么把 badapple 數據編譯進固件

硬件

我這里用到的顯示器是 SPI 接口的 OLED 模塊，驅動芯片是 SSD1306，如下：

既然是使用 SPI接口，就要用到 NUC980 的SPI接口了，上圖，還是這樣用過了好幾次的圖，NuMaker-RTU-NUC980 板子引出的 IO：

可以看到板子上引出了 SPI0，還需要 2 個 GPIO 用於 OELD的 RST、DC，接線如下：

OLED     NUC980
D0	<--  PC6
D1	<--  PC8
RST	<--  PB4
DC	<--  PB6
CS	<--  PC5

實物如下：

把 OLED 驅動起來

RT-Thread 中 SPI 接口也有相應的驅動框架、對於的API，具體可以查看 RT-Thread 相應文檔 -- SPI設備 ，

首先定義一個 spi 設備，然后掛載到 SPI0，設置 SPI 參數，並把另外用到的 2 個 IO 設置為輸出，如下：

static struct rt_spi_device spi_dev_lcd;

#define SSD1306_DC_PIN  NU_GET_PININDEX(NU_PB, 6)
#define SSD1306_RES_PIN NU_GET_PININDEX(NU_PB, 4)

static int rt_hw_ssd1306_config(void)
{
    if (rt_spi_bus_attach_device(&spi_dev_lcd, "lcd_ssd1306", "spi0", RT_NULL) != RT_EOK)
        return -RT_ERROR;

    /* config spi */
    {
        struct rt_spi_configuration cfg;
        cfg.data_width = 8;
        cfg.mode = RT_SPI_MASTER | RT_SPI_MODE_3 | RT_SPI_MSB;
        cfg.max_hz = 42 * 1000 * 1000; /* 42M,SPI max 42MHz,lcd 4-wire spi */

        rt_spi_configure(&spi_dev_lcd, &cfg);
    }

    rt_pin_mode(SSD1306_DC_PIN, PIN_MODE_OUTPUT);
    rt_pin_mode(SSD1306_RES_PIN, PIN_MODE_OUTPUT);

    return RT_EOK;
}

然后實現對 OLED 寫命令、數據函數：

static rt_err_t ssd1306_write_cmd(const rt_uint8_t cmd)
{
    rt_size_t len;

    rt_pin_write(SSD1306_DC_PIN, PIN_LOW);

    rt_spi_transfer(&spi_dev_lcd, (const void *)&cmd, NULL, 1);
    if (len != 1)
    {
        LOG_I("ssd1306_write_cmd error. %d", len);
        return -RT_ERROR;
    }
    else
    {
        return RT_EOK;
    }
}

static rt_err_t ssd1306_write_data(const rt_uint8_t data)
{
    rt_size_t len;

    rt_pin_write(SSD1306_DC_PIN, PIN_HIGH);
    rt_spi_transfer(&spi_dev_lcd, (const void *)&data, NULL, 1);

    if (len != 1)
    {
        LOG_I("ssd1306_write_data error. %d", len);
        return -RT_ERROR;
    }
    else
    {
        return RT_EOK;
    }
}

實現 OLED 初始化、寫屏、清屏函數：

void ssd1306_fill(uint8_t *dat)
{
	uint8_t i,n;		    
	for(i=0;i<8;i++)  
	{  
		ssd1306_write_cmd (0xb0+i);   
		ssd1306_write_cmd (0x00);      
		ssd1306_write_cmd (0x10);      
		for(n=0;n<128;n++)
        {
            ssd1306_write_data(*dat); 
            dat ++;
        }
            
	}   
}

void ssd1306_clear(void)  
{  
	uint8_t i,n;		    
	for(i=0;i<8;i++)  
	{  
		ssd1306_write_cmd (0xb0+i);   
		ssd1306_write_cmd (0x00);      
		ssd1306_write_cmd (0x10);      
		for(n=0;n<128;n++)
        {
            ssd1306_write_data(0x00); 
            dat ++;
        }
            
	} 
}


static int rt_hw_ssd1306_init(void)
{
    
    rt_hw_ssd1306_config();

    rt_pin_write(SSD1306_RES_PIN, PIN_HIGH);
    rt_thread_delay(RT_TICK_PER_SECOND / 10);
    rt_pin_write(SSD1306_RES_PIN, PIN_LOW);
    //wait at least 100ms for reset
    rt_thread_delay(RT_TICK_PER_SECOND / 10);
    rt_pin_write(SSD1306_RES_PIN, PIN_HIGH);

	ssd1306_write_cmd(0xAE); 
	ssd1306_write_cmd(0xD5); 
	ssd1306_write_cmd(80);  
	ssd1306_write_cmd(0xA8);
	ssd1306_write_cmd(0X3F);
	ssd1306_write_cmd(0xD3); 
	ssd1306_write_cmd(0X00);

	ssd1306_write_cmd(0x40); 
													    
	ssd1306_write_cmd(0x8D); 
	ssd1306_write_cmd(0x14); 
	ssd1306_write_cmd(0x20); 
	ssd1306_write_cmd(0x02); 
	ssd1306_write_cmd(0xA1); 
	ssd1306_write_cmd(0xC0);
	ssd1306_write_cmd(0xDA); 
	ssd1306_write_cmd(0x12); 
		 
	ssd1306_write_cmd(0x81); 
	ssd1306_write_cmd(0xEF);
	ssd1306_write_cmd(0xD9); 
	ssd1306_write_cmd(0xf1); 
	ssd1306_write_cmd(0xDB); 
	ssd1306_write_cmd(0x30); 

	ssd1306_write_cmd(0xA4); 
	ssd1306_write_cmd(0xA6); 
	ssd1306_write_cmd(0xAF); 

    ssd1306_clear();

    return RT_EOK;
}
INIT_COMPONENT_EXPORT(rt_hw_ssd1306_init);

把 badapple 數據編譯進固件（1）

首先想到的是最常用的方法，把 badapple 數據放在一個數組里，然后把該數組的內容寫入 OLED 就行了，因為 badapple 數據是二進制，轉成數組形式的話，放在代碼里面，就相當於把二進制轉成字符串，比如以下數據：

對於第一行，轉成數組形式的話，如下：

uint8_t example[] = {0x23,0x78,0x33,0xb9,0x04,0x4b,0x13,0xb1,0x04,0x48,0xaf,0xf3,0x00,0x80,0x01,0x23};

如果數量不多的話，還好手動轉換下，可是對於這個有 5 點幾兆的，也就是有 5383168 字節，上百萬個字節，手動轉換肯定不實際，也沒去找有沒有什么現成工具可以用，我自己用 python 寫了個小程序，把這個轉換出來了，來感受下：

看了下，有30多萬行，我電腦打開這文件都會有點卡頓，

經過這么一頓操作，我可是代碼量超過 10萬行的了，還是輕輕松松、隨隨便便就達到了。

把該文件放到工程里面，然后寫個播放 badapple 的函數：

int badappple_test(int argc, char **argv)
{
    uint32_t len =0,frame = 0,i=0,index = 0;
    rt_tick_t start = 	rt_tick_get();
    len = sizeof(badapple);
    frame = len / 1024;
    
    for(i=0;i<frame;i++)
    {
        ssd1306_fill(&badapple[i * 1024]);
    }
    rt_tick_t end = 	rt_tick_get();
    rt_kprintf("Frame:%d\r\n",frame);
    rt_kprintf("start:%d, end:%d, use:%d\r\n",start,end,end-start);
    rt_kprintf("1 s tick:%d\r\n",rt_tick_from_millisecond(1000));
}
MSH_CMD_EXPORT(badappple_test, badappple test);

開始的時候獲取滴答定時器當前的值：

rt_tick_t start = 	rt_tick_get();

然后獲取 badapple 數據對應的數組的長度，計算幀數：

    len = sizeof(badapple);
    frame = len / 1024;

然后就是寫屏了：

    for(i=0;i<frame;i++)
    {
        ssd1306_fill(&badapple[i * 1024]);
    }

最后獲取結束的時候的滴答定時器的值，用於計算幀率：

  rt_tick_t end = 	rt_tick_get();
  rt_kprintf("Frame:%d\r\n",frame);
  rt_kprintf("start:%d, end:%d, use:%d\r\n",start,end,end-start);
  rt_kprintf("1 s tick:%d\r\n",rt_tick_from_millisecond(1000));

編譯，看下編譯出來的固件大小：

也是有 5 點幾兆，最后運行效果為：

nuc980 播放 badapple

串口終端輸出的信息：

可以看到播放持續了 23.238 秒，可以計算出幀率為：

5257 / 23.238 = 226.22

226 幀每秒，這會不會是全網用單片機播放 badapple 中幀率最高的呢，

把 badapple 數據編譯進固件（2）

對於第一種方法，由於要經過轉換，有點麻煩，突然想到之前看到過一套 GUI 源碼，代碼工程里面是直接把二進制進固件，忘記具體是怎么實現的，上網搜了下，實驗了幾次，居然做出來了，具體做法如下。

實現這個功能的關鍵是 incbin 指令，該指令是一條 arm 偽指令，功能是把一個文件包含到當前的源文件中，編譯的時候會把該文件以二進制的形式編譯進固件中。由於該指令是匯編，所以需要創建一個 .s 文件，內容為：

  .section .rodata
  .global BADAPPLE_FILE 
  .type   BADAPPLE_FILE, %object 
  .align 4
BADAPPLE_FILE:       
  .incbin "applications/badapple.bin"
BADAPPLE_FILE__END:
  .global BADAPPLE_FILE_SIZE
  .type   BADAPPLE_FILE_SIZE, %object
  .align 4
BADAPPLE_FILE_SIZE:
  .int BADAPPLE_FILE__END - BADAPPLE_FILE 

這里定義了 2 個全局變量 BADAPPLE_FILE、BADAPPLE_FILE_SIZE，BADAPPLE_FILE 是 badapple 數據開始位置，相當於一個數組頭字節地址，BADAPPLE_FILE_SIZE，是 badapple 數據大小。把該 .s 文件 跟 badappel.bin 同時放到 工程中的 applications 目錄下，還要修改下 applications 的 SConscript 文件，因為默認是沒有編譯該目錄下的 .s 文件，修改為：

# RT-Thread building script for component

from building import *

cwd = GetCurrentDir()
src = Glob('*.c') + Glob('*.cpp')  + Glob('*.s')
CPPPATH = [cwd, str(Dir('#'))]

group = DefineGroup('Applications', src, depend = [''], CPPPATH = CPPPATH)

Return('group')

接下里就實現播放 badapple 函數：

extern const uint8_t BADAPPLE_FILE;
const uint8_t *badapple_p = &BADAPPLE_FILE;
extern uint32_t BADAPPLE_FILE_SIZE;
int badappple_test(int argc, char **argv)
{
    uint32_t frame = 0,i=0,index = 0;
    rt_tick_t start = 	rt_tick_get();
    frame = BADAPPLE_FILE_SIZE / 1024;
    
    for(i=0;i<frame;i++)
    {
        ssd1306_fille((uint8_t *)&badapple_p[i * 1024]);
    }
    rt_tick_t end = 	rt_tick_get();
    rt_kprintf("file size is:%d",BADAPPLE_FILE_SIZE);
    rt_kprintf("Frame:%d\r\n",frame);
    rt_kprintf("start:%d, end:%d, use:%d\r\n",start,end,end-start);
    rt_kprintf("1 s tick:%d\r\n",rt_tick_from_millisecond(1000));
}
MSH_CMD_EXPORT(badappple_test, badappple test);

編譯運行，經過測試，效果跟上一個方法是一樣的。

轉載請注明出處：https://www.cnblogs.com/halin/