1. 程式人生 > >第20課 SPI協議詳解及裸機程式開發分析

第20課 SPI協議詳解及裸機程式開發分析

第001節_SPI協議介紹

市面上的開發板很少接有SPI裝置,但是SPI協議在工作中經常用到。我們開發了SPI模組,上面有SPI Flash和SPI OLED。OLED就是一塊顯示器。

我們裸板程式會涉及兩部分:

  • 用GPIO模擬SPI
  • 用S3C2440的SPI控制器

我們先介紹下SPI協議,硬體框架如下:

這裡寫圖片描述

  • SCK:提供時鐘
  • DO:作為資料輸出
  • DI:作為資料輸入
  • CS0/CS1:作為片選

同一時刻只能有一個SPI裝置處於工作狀態。

假設現在2440傳輸一個0x56資料給SPI Flash,時序如下:
這裡寫圖片描述
首先CS0先拉低選中SPI Flash,0x56的二進位制就是0b0101 0110,因此在每個SCK時鐘週期,DO輸出對應的電平。
SPI Flash會在每個時鐘週期的上升沿讀取D0上的電平。

在SPI協議中,有兩個值來確定SPI的模式。
CPOL:表示SPICLK的初始電平,0為電平,1為高電平
CPHA:表示相位,即第一個還是第二個時鐘沿取樣資料,0為第一個時鐘沿,1為第二個時鐘沿

CPOL CPHA 模式 含義
0 0 0 初始電平為低電平,在第一個時鐘沿取樣資料
0 1 1 初始電平為低電平,在第二個時鐘沿取樣資料
1 0 2 初始電平為高電平,在第一個時鐘沿取樣資料
1 1 3 初始電平為高電平,在第二個時鐘沿取樣資料

我們常用的是模式0和模式3,因為它們都是在上升沿取樣資料,不用去在乎時鐘的初始電平是什麼,只要在上升沿採集資料就行。

極性選什麼?格式選什麼?通常去參考外接的模組的晶片手冊。比如對於OLED,檢視它的晶片手冊時序部分:
這裡寫圖片描述

SCLK的初始電平我們並不需要關心,只要保證在上升沿取樣資料就行。

第002節_使用GPIO實現SPI協議操作OLED

現在開始寫程式碼,使用GPIO實現SPI協議操作。

我們現在想要操作OLED,通過三條線(SCK、DO、CS)與OLED相連,這裡沒有DI是因為2440只會向OLED傳資料而不用接收資料。

我們要用GPIO來實現SOC向OLED寫資料,這一層用gpio_spi.c來實現,負責傳送資料。

對於OLED,有專門的指令和資料格式,要傳輸的資料內容,在oled.c這一層來實現,負責組織資料。

因此,我們需要實現以上兩個檔案。
這裡寫圖片描述

需要實現的函式:先SPI初始化SPIInt(),再初始化OLEDOLEDInit(),最後再顯示OLEDPrint()。

新建一個gpio_spi.c檔案,實現SPI初始化SPIInt()

void SPIInit(void)
{
    /* 初始化引腳 */
    SPI_GPIO_Init();
}

再具體實現SPI_GPIO_Init()。這裡使用GPIO實現SPI協議,電路圖如下:
這裡寫圖片描述

 GPF1作為OLED片選引腳,設定為輸出;
 GPG2作為FLASH片選引腳,設定為輸出;
 GPG4作為OLED的資料(Data)/命令(Command)選擇引腳,設定為輸出;
 GPG5作為SPI的MISO,設定為輸入;
 GPG6作為SPI的MOSI,設定為輸出;
 GPG7作為SPI的時鐘CLK,設定為輸出;
/* 用GPIO模擬SPI */
static void SPI_GPIO_Init(void)
{
    /* GPF1 OLED_CSn output */
    GPFCON &= ~(3<<(1*2));
    GPFCON |= (1<<(1*2));
    GPFDAT |= (1<<1);

    /* GPG2 FLASH_CSn output
    * GPG4 OLED_DC   output
    * GPG5 SPIMISO   input
    * GPG6 SPIMOSI   output
    * GPG7 SPICLK    output
    */
    GPGCON &= ~((3<<(2*2)) | (3<<(4*2)) | (3<<(5*2)) | (3<<(6*2)) | (3<<(7*2)));
    GPGCON |= ((1<<(2*2)) | (1<<(4*2)) | (1<<(6*2)) | (1<<(7*2)));
    GPGDAT |= (1<<2);
}

再新建一個oled.c檔案,以實現初始化OLEDOLEDInit()

void OLEDInit(void)
{
/* 向OLED發命令以初始化 */
}

查閱OLED資料手冊SPEC UG-2864TMBEG01.pdf可以得知其初始化流程和參考的初始化程式碼:

void OLEDInit(void)
{
    /* 向OLED發命令以初始化 */
    OLEDWriteCmd(0xAE); /*display off*/ 
    OLEDWriteCmd(0x00); /*set lower column address*/ 
    OLEDWriteCmd(0x10); /*set higher column address*/ 
    OLEDWriteCmd(0x40); /*set display start line*/ 
    OLEDWriteCmd(0xB0); /*set page address*/ 
    OLEDWriteCmd(0x81); /*contract control*/ 
    OLEDWriteCmd(0x66); /*128*/ 
    OLEDWriteCmd(0xA1); /*set segment remap*/ 
    OLEDWriteCmd(0xA6); /*normal / reverse*/ 
    OLEDWriteCmd(0xA8); /*multiplex ratio*/ 
    OLEDWriteCmd(0x3F); /*duty = 1/64*/ 
    OLEDWriteCmd(0xC8); /*Com scan direction*/ 
    OLEDWriteCmd(0xD3); /*set display offset*/ 
    OLEDWriteCmd(0x00); 
    OLEDWriteCmd(0xD5); /*set osc division*/ 
    OLEDWriteCmd(0x80); 
    OLEDWriteCmd(0xD9); /*set pre-charge period*/ 
    OLEDWriteCmd(0x1f); 
    OLEDWriteCmd(0xDA); /*set COM pins*/ 
    OLEDWriteCmd(0x12); 
    OLEDWriteCmd(0xdb); /*set vcomh*/ 
    OLEDWriteCmd(0x30); 
    OLEDWriteCmd(0x8d); /*set charge pump enable*/ 
    OLEDWriteCmd(0x14); 
}

因此我們還要先實現OLEDWriteCmd()函式,對於OLED,除了SPI的片選、時鐘、資料引腳,還有一個數據/命令切換引腳。
這裡寫圖片描述

這裡的D/C即資料(Data)/命令(Command)選擇引腳,它為高電平時,OLED即認為收到的是資料;它為低電平時,OLED即認為收到的是命令。

對於OLED,命令由開啟/關閉顯示、背光亮度等,具體有什麼命令,可以查閱OLED的主控晶片手冊SSD1306-Revision 1.1 (Charge Pump).pdf,在9 COMMAND TABLE 有相關命令的介紹。

因此,在編寫OLEDWriteCmd()時,需要先設定為命令模式:

static void OLEDWriteCmd(unsigned char cmd)
{
    OLED_Set_DC(0); /* command */
    OLED_Set_CS(0); /* select OLED */

    SPISendByte(cmd);

    OLED_Set_CS(1); /* de-select OLED */
    OLED_Set_DC(1); /*  */
}

即:先設定為命令模式,再片選OLED,再傳輸命令,再恢復成原來的模式和取消片選。

片選函式和模式切換函式都比較簡單,設定為對應的高低電平即可:

static void OLED_Set_DC(char val)
{
    if (val)
        GPGDAT |= (1<<4);
    else
        GPGDAT &= ~(1<<4);
}

static void OLED_Set_CS(char val)
{
    if (val)
        GPFDAT |= (1<<1);
    else
        GPFDAT &= ~(1<<1);
}

還剩下SPISendByte()函式,它屬於SPI協議,放在gpio_spi.c裡面:

void SPISendByte(unsigned char val)
{
    int i;
    for (i = 0; i < 8; i++)
    {
        SPI_Set_CLK(0);
        SPI_Set_DO(val & 0x80);
        SPI_Set_CLK(1);
        val <<= 1;
    }

}

傳送資料要滿足SPI的時序要求,參考前面的介紹:
這裡寫圖片描述

先設定CLK為低,然後資料引腳輸出資料的最高位,然後CLK為高,在CLK這個上升沿中,OLED就讀取了一位資料。接著左移一位,將原來的第7位移動到了第8位,重複8次,傳輸完成。

再完成SPI_Set_CLK()和SPI_Set_DO():


static void SPI_Set_CLK(char val)
{
    if (val)
        GPGDAT |= (1<<7);
    else
        GPGDAT &= ~(1<<7);
}

static void SPI_Set_DO(char val)
{
    if (val)
        GPGDAT |= (1<<6);
    else
        GPGDAT &= ~(1<<6);
}

至此,SPI初始化和OLED初始化就基本完成了,接下來就是OLED顯示部分。

先了解一下OLED顯示的原理:
這裡寫圖片描述

OLED長有128個畫素,寬有64個畫素,每個畫素用一位來表示,為1則亮,為0則滅。

每一個位元組資料Datax控制每列8個畫素,在視訊記憶體裡面存放Data資料。

之後所需的操作就是把資料寫到視訊記憶體裡面去,如何寫到視訊記憶體可以拆分成兩個問題:

①怎麼發地址
②怎麼發資料

OLED主控的手冊裡介紹了三種地址模式,我們常用的是頁地址模式(Page addressing mode (A[1:0]=10xb)),它把視訊記憶體的64行分為8頁,每頁對應8行;選中某頁後,再選擇某列,然後就可以往裡面寫資料了,每寫一個數據,地址就會加1,一直寫到最右端的位置,他會自動跳到最左端。

通過命令來實現傳送頁地址和列地址,其中列地址分為兩次傳送,先發送低位元組,再發送高位元組。

假設每個字元資料大小為8x16,假如第一個字元位置為(page,col),相鄰的右邊就是(page,col+8),寫滿一行跳至下一行的座標就是(page+2,col)。

/* page: 0-7
 * col : 0-127
 * 字元: 8x16象素
 */
void OLEDPrint(int page, int col, char *str)
{
    int i = 0;
    while (str[i])
    {
        OLEDPutChar(page, col, str[i]);
        col += 8;
        if (col > 127)
        {
            col = 0;
            page += 2;
        }
        i++;
    }
}

只要字元陣列str[i]有資料,就呼叫OLEDPutChar(page, col, str[i])在指定位置顯示第一個字元,然後位置向右移動一個字元的大小,如果遇到行尾,再進行換行,就這樣依次顯示完所有字元。

現在開始實現最重要的OLEDPutChar()函式。把一個字元在OLED上顯示出來需要以下幾個步驟:

a. 得到字模

b. 發給OLED

字模我們可以從網上搜索相關資料獲取到,將字模的陣列oled_asc2_8x16[95][16]放在oledfont.c裡面,字元從空格開始,因此每次減去一個空格才是我們想要的字元。

如圖所示一個字元,先以(page, col)為起點,顯示8位資料,再換行,以(page+1, col)為起點顯示8位資料。
這裡寫圖片描述


/* page: 0-7
 * col : 0-127
 * 字元: 8x16象素
 */
void OLEDPutChar(int page, int col, char c)
{
    int i = 0;
    /* 得到字模 */
    const unsigned char *dots = oled_asc2_8x16[c - ' '];

    /* 發給OLED */
    OLEDSetPos(page, col);
    /* 發出8位元組資料 */
    for (i = 0; i < 8; i++)
        OLEDWriteDat(dots[i]);

    OLEDSetPos(page+1, col);
    /* 發出8位元組資料 */
    for (i = 0; i < 8; i++)
        OLEDWriteDat(dots[i+8]);
}

顯示一個字元,就先獲取字模資料,接著發出8位元組資料,再換行發出8位元組數。

再來實現OLED設定座標位置函式,先設定page:
這裡寫圖片描述
D0~D2表示page資料,D3-D7是固定的值,因此每次寫的命令內容為0xB0+page;

再設定列:
這裡寫圖片描述

分兩次傳送,顯示傳送低位元組4位,再發送高位元組四位;

static void OLEDSetPos(int page, int col)
{
    OLEDWriteCmd(0xB0 + page); /* page address */

    OLEDWriteCmd(col & 0xf);   /* Lower Column Start Address */
    OLEDWriteCmd(0x10 + (col >> 4));   /* Lower Higher Start Address */
}

前面提到了OLED主控有三種地址模式,我們常用的是頁地址模式(Page addressing mode (A[1:0]=10xb)),雖然這是預設的摸索,但還是設定一下比較好:
這裡寫圖片描述

即先發送0x20,再設定A[1:0]=10:

static void OLEDSetPageAddrMode(void)
{
    OLEDWriteCmd(0x20);
    OLEDWriteCmd(0x02);
}

在顯示中,一般都需一個清屏函式來清空當前可能顯示的資料。清屏函式比較簡單,往所有位置裡面寫0即可:

static void OLEDClear(void)
{
    int page, i;
    for (page = 0; page < 8; page ++)
    {
        OLEDSetPos(page, 0);
        for (i = 0; i < 128; i++)
            OLEDWriteDat(0);
    }
}

再把地址模式OLEDSetPageAddrMode()和清屏函式OLEDClear()放在SPI_GPIO_Init()裡,在Makefile加上gpio_spi.o和oled.o。

最後在主函式里加上初始化和顯示函式:

 SPIInit();
 OLEDInit();
 OLEDPrint(0,0,"www.100ask.net, 100ask.taobao.com");

第003節SPI_FLASH程式設計讀ID

這節講解如何使用SPI操作Flash,我們在上節課的程式碼上進行修改,新增一個檔案 spi_flash.c 和其標頭檔案 spi_flash.h 。

我們先做一個最簡單的spi操作,讀取Flash的ID, SPIFlashID() 。

Flash的ID有廠家ID和裝置ID,分別用pMID和pDID來儲存。

根據Flash的晶片手冊 W25Q16DV.pdf 可以知道需要先發出一個指令0x90,再發送24位的地址0,再讀取資料前8位是裝置ID,然後是8位裝置ID。進行操作前必須要片選SPI Flash,片選完還是釋放SPI Flash:

這裡寫圖片描述

void SPIFlashReadID(int *pMID, int *pDID)
{
    SPIFlash_Set_CS(0); /* 選中SPI FLASH */

    SPISendByte(0x90);

    SPIFlashSendAddr(0);

    *pMID = SPIRecvByte();
    *pDID = SPIRecvByte();

    SPIFlash_Set_CS(1);
}

把其中的傳送24地址封裝成了一個函式 SPIFlashSendAddr() :


static void SPIFlashSendAddr(unsigned int addr)
{
    SPISendByte(addr >> 16);
    SPISendByte(addr >> 8);
    SPISendByte(addr & 0xff);
}

依次完成上面的子函式,先是SPI片選,上一節的原理圖可以看到SPI Flash的片選是GPG2:

static void SPIFlash_Set_CS(char val)
{
    if (val)
        GPGDAT |= (1<<2);
    else
        GPGDAT &= ~(1<<2);
}

SPISendByte() 和前面OLED的是一樣的,就不用寫了,因此就只剩下 SPIRecvByte() ,放在 gpio_spi.c 裡面實現:

unsigned char SPIRecvByte(void)
{
    int i;
    unsigned char val = 0;
    for (i = 0; i < 8; i++)
    {
        val <<= 1;
        SPI_Set_CLK(0);
        if (SPI_Get_DI())
            val |= 1;
        SPI_Set_CLK(1);
    }
    return val;    
}

在每個時鐘週期讀取DI引腳上的值,對於SOC就是MISO引腳:

static char SPI_Get_DI(void)
{
    if (GPGDAT & (1<<5))
        return 1;
    else 
        return 0;
}

至此,讀取Flash的ID基本實現,最後在主函式裡呼叫列印,分別在串列埠和OLED上顯示:


    SPIFlashReadID(&mid, &pid);
    printf("SPI Flash : MID = 0x%02x, PID = 0x%02x\n\r", mid, pid);

    sprintf(str, "SPI : %02x, %02x", mid, pid);
    OLEDPrint(4,0,str);

Makefile記得加上新生成的 spi_flash.o 。

第004節SPI_FLASH程式設計讀寫

Flash作為一個儲存晶片,最重要的就是儲存和讀取儲存的資料,這節我們就實現Flash裡資料的讀寫。
對於Flash,每次寫操作需要的步驟如下:

  • 去保護(寫使能、寫狀態暫存器);
  • 擦除(寫使能)
  • 編寫入資料(寫使能)

可以看出對於寫操作,每次都要寫使能,查閱晶片手冊,可以看出寫使能比較簡單,只需要傳送0x06命令即可:
這裡寫圖片描述

反之,防寫則是寫入0x04:
這裡寫圖片描述

static void SPIFlashWriteEnable(int enable)
{
    if (enable)
    {
        SPIFlash_Set_CS(0);
        SPISendByte(0x06);
        SPIFlash_Set_CS(1);
    }
    else
    {
        SPIFlash_Set_CS(0);
        SPISendByte(0x04);
        SPIFlash_Set_CS(1);
    }
}

然後是讀寫狀態暫存器,狀態暫存器有兩個,通過0x05讀取狀態暫存器1,通過0x35讀取狀態暫存器2:
這裡寫圖片描述


static unsigned char SPIFlashReadStatusReg1(void)
{
    unsigned char val;
    SPIFlash_Set_CS(0);
    SPISendByte(0x05);
    val = SPIRecvByte();
    SPIFlash_Set_CS(1);
    return val;
}

static unsigned char SPIFlashReadStatusReg2(void)
{
    unsigned char val;
    SPIFlash_Set_CS(0);
    SPISendByte(0x35);
    val = SPIRecvByte();
    SPIFlash_Set_CS(1);
    return val;
}

寫狀態暫存器則是先發出0x01命令,再依次傳送狀態暫存器1、狀態暫存器2:
這裡寫圖片描述

static void SPIFlashWriteStatusReg(unsigned char reg1, unsigned char reg2)
{    
    SPIFlashWriteEnable(1);  

    SPIFlash_Set_CS(0);
    SPISendByte(0x01);
    SPISendByte(reg1);
    SPISendByte(reg2);
    SPIFlash_Set_CS(1);

    SPIFlashWaitWhenBusy();
}

寫狀態暫存器還需要去保護,預設的是發出SPIFlashWriteEnable()後,即可寫狀態暫存器,但為了確保萬無一失,還是手動在將SRP1和SRP2設定為0,即將狀態暫存器1的最高位清零和狀態暫存器最低位清零:
這裡寫圖片描述
這裡寫圖片描述

static void SPIFlashClearProtectForStatusReg(void)
{
    unsigned char reg1, reg2;

    reg1 = SPIFlashReadStatusReg1();
    reg2 = SPIFlashReadStatusReg2();

    reg1 &= ~(1<<7);
    reg2 &= ~(1<<0);

    SPIFlashWriteStatusReg(reg1, reg2);
}

Flash有兩種保護機制,一個是保護狀態暫存器,一種是保護儲存資料,現在再來清除資料保護。
需要將CMP設定為0的同時,將BP0、BP1、BP2都設定為0:
這裡寫圖片描述
這裡寫圖片描述

static void SPIFlashClearProtectForData(void)
{
    /* cmp=0,bp2,1,0=0b000 */
    unsigned char reg1, reg2;

    reg1 = SPIFlashReadStatusReg1();
    reg2 = SPIFlashReadStatusReg2();

    reg1 &= ~(7<<2);
    reg2 &= ~(1<<6);

    SPIFlashWriteStatusReg(reg1, reg2);
}
 ```
將兩個清除防寫都放在一起,作為一個SPI Flash初始化函式:
 ```
void SPIFlashInit(void)
{
    SPIFlashClearProtectForStatusReg();
    SPIFlashClearProtectForData();
}

再來實現擦除,擦除命令需要先發一個0x20的命令,再發出24位的想擦除位置的地址:
這裡寫圖片描述

/* erase 4K */
void SPIFlashEraseSector(unsigned int addr)
{
    SPIFlashWriteEnable(1);  

    SPIFlash_Set_CS(0);
    SPISendByte(0x20);
    SPIFlashSendAddr(addr);
    SPIFlash_Set_CS(1);

    SPIFlashWaitWhenBusy();
}

為了保證擦除成功,需要讀取狀態暫存器1的的第1位:

static void SPIFlashWaitWhenBusy(void)
{
    while (SPIFlashReadStatusReg1() & 1);
}

然後是燒寫函式,先發命令0x02,再發出24位地址,最後再逐個傳送資料:
這裡寫圖片描述

/* program */
void SPIFlashProgram(unsigned int addr, unsigned char *buf, int len)
{
    int i;

    SPIFlashWriteEnable(1);  

    SPIFlash_Set_CS(0);
    SPISendByte(0x02);
    SPIFlashSendAddr(addr);

    for (i = 0; i < len; i++)
        SPISendByte(buf[i]);

    SPIFlash_Set_CS(1);

    SPIFlashWaitWhenBusy();

}

同前面的擦除操作一樣,燒寫操作也不是一定是實時的,需要讀取狀態標誌位來判斷是否完成。

讀函式也是類似的操作,先發命令0x03,再發出24位地址,再逐個讀取資料:
這裡寫圖片描述

void SPIFlashRead(unsigned int addr, unsigned char *buf, int len)
{
    int i;

    SPIFlash_Set_CS(0);
    SPISendByte(0x03);
    SPIFlashSendAddr(addr);
    for (i = 0; i < len; i++)
        buf[i] = SPIRecvByte();

    SPIFlash_Set_CS(1);    
}

至此,基本的Flash讀寫功能已經完成,在主函式呼叫擦除函式擦除4096這個扇區的資料,再往4096這個地方寫入字串,再從該地址讀取出來,在串列埠和OLED打印出來:

 SPIFlashEraseSector(4096);
 SPIFlashProgram(4096, "100ask", 7);
 SPIFlashRead(4096, str, 7);
 printf("SPI Flash read from 4096: %s\n\r", str);
 OLEDPrint(4,0,str);

第005節_在OLED上顯示ADC的值

這節我們在OLED顯示ADC電壓值,通過調節可調電阻,讓ADC的值在螢幕上不斷變化。
在JZ2440的主光碟的hardware裡面有一個adc_ts觸控式螢幕的程式,把裡面的adc_ts.c和adc_ts.h提取出來放在本節視訊待寫的程式碼裡面。
主函式呼叫的是Test_Adc.c進行測試adc,因此在裡面加上列印和OLED顯示函式。

/* 
 * 測試ADC
 * 通過A/D轉換,測量可變電阻器的電壓值
 */       
void Test_Adc(void)
{
    float vol0, vol1;
    int t0, t1;
    char buf[100];

    printf("Measuring the voltage of AIN0 and AIN1, press any key to exit\n\r");
    while (!awaitkey(0))    // 串列埠無輸入,則不斷測試
    {
        vol0 = ((float)ReadAdc(0)*3.3)/1024.0;  // 計算電壓值
        vol1 = ((float)ReadAdc(1)*3.3)/1024.0;  // 計算電壓值
        t0   = (vol0 - (int)vol0) * 1000;   // 計算小數部分, 本程式碼中的printf無法列印浮點數
        t1   = (vol1 - (int)vol1) * 1000;   // 計算小數部分,  本程式碼中的printf無法列印浮點數
        printf("AIN0 = %d.%-3dV    AIN1 = %d.%-3dV\r", (int)vol0, t0, (int)vol1, t1);

        sprintf(buf,"ADC: %d.%-3d, %d.%-3d", (int)vol0, t0, (int)vol1, t1);

        OLEDPrint(6, 0, buf);
    }
    printf("\n");
}

這裡呼叫了一個awaitkey()函式,需要再複製adc_ts觸控式螢幕的程式裡serial.c的該函式到本工程裡面。

/*
 * 接收字元,若有資料直接返回,否則等待規定的時間
 * 輸入引數:
 *     timeout: 等待的最大迴圈次數,0表示不等待
 * 返回值: 
 *    0     : 無資料,超時退出
 *    其他值:串列埠接收到的資料
 */
unsigned char awaitkey(unsigned long timeout)
{
    while (!(UTRSTAT0 & RXD0READY))
    {
        if (timeout > 0)
            timeout--;
        else
            return 0;   // 超時,返回0
    }

    return URXH0;       // 返回接收到的串列埠資料
}

修改Makefile,加入adc_ts.o,編譯,報錯,涉及除法操作,需要加入數學庫:

LDFLASG := -L (shelldirname(CC) $(CFLAGS) -print-libgcc-file-name) -lgcc

現在重新編譯即可通過。

現在將IIC的的結果也在OLED上顯示出來,在主函式新增如下程式碼:

    i2c_init();

    at24cxx_write(0, 0x55);
    data = at24cxx_read(0);

    OLEDClearPage(2);
    OLEDClearPage(3);

    if (data == 0x55)    
        OLEDPrint(2,0,"I2C OK!");
    else
        OLEDPrint(2,0,"I2C Err!");

先初始化iic,在0地址寫入0x55,然後再讀取出來,判斷是否與寫入的一樣,一樣則列印OK,否則列印Err。

為了防止OLED出現之前顯示的資料殘留,需要再寫一個清除Page的函式:

void OLEDClearPage(int page)
{
    int i;
    OLEDSetPos(page, 0);
    for (i = 0; i < 128; i++)
        OLEDWriteDat(0);    
}

第006節_使用SPI控制器

前面我們都是通過GPIO管腳來實現的SPI通訊,這節我們使用2440裡面的GPIO控制器來實現SPI通訊。

前面使用GPIO傳送資料時,是手工的控制時鐘線、資料線,我們使用SPI控制器的話,只需要
把資料寫入暫存器,它就可以幫我自動那些時鐘線和資料線,我們繼續在上一節的基礎上修改,新增一個檔案s3c2440_spi.c和s3c2440_spi.h,同時修改Makefile,替換gpio_spi.c為s3c2440_spi.o。

從初始化函式開始,需要管腳初始化和SPI控制器初始化:

void SPIInit(void)
{
    /* 初始化引腳 */
    SPI_GPIO_Init();

    SPIControllerInit();
}

管腳初始化即需要把SPI相關的CLK、MOSI、MISO配置為對應的功能引腳:

static void SPI_GPIO_Init(void)
{
    /* GPF1 OLED_CSn output */
    GPFCON &= ~(3<<(1*2));
    GPFCON |= (1<<(1*2));
    GPFDAT |= (1<<1);

    /* GPG2 FLASH_CSn output
    * GPG4 OLED_DC   output
    * GPG5 SPIMISO   
    * GPG6 SPIMOSI   
    * GPG7 SPICLK     
    */
    GPGCON &= ~((3<<(2*2)) | (3<<(4*2)) | (3<<(5*2)) | (3<<(6*2)) | (3<<(7*2)));
    GPGCON |= ((1<<(2*2)) | (1<<(4*2)) | (3<<(5*2)) | (3<<(6*2)) | (3<<(7*2)));
    GPGDAT |= (1<<2);
}

然後是SPI控制器的初始化,控制器的初始化可以參考晶片手冊介紹的程式設計步驟:
這裡寫圖片描述

首先是設定波特率,要根據外設所能接受的範圍來設定,比如查閱OLED的晶片手冊得知其時鐘最小值為100ns,即最小為10MHz;Flash時鐘支援最大104MHz,為了程式碼簡單,就直接取10MHz,根據等式推出暫存器值:

Baud rate = PCLK / 2 / (Prescaler value + 1)
10 = 50 / 2 / (Prescaler value + 1)
Prescaler value = 1.5 = 2

實際的波特率為:50/2/3=8.3MHz

根據參考流程,接下來設定SPI控制暫存器:
這裡寫圖片描述

 [6:5]設定為查詢模式: 00 polling mode
 [4]設定時鐘使能: 1 = enable 
 [3]設定為主機模式: 1 = master
 [2]設定無資料時時鐘為低電平: 0
 [1]設定工作模式為模式A: 0 = format A
 [0]設定傳送資料時無需讀取資料: 0 = normal mode
static void SPIControllerInit(void)
{
    /* OLED  : 100ns, 10MHz
    * FLASH : 104MHz
    * 取10MHz
    * 10 = 50 / 2 / (Prescaler value + 1)
    * Prescaler value = 1.5 = 2
    * Baud rate = 50/2/3=8.3MHz
    */
    SPPRE0 = 2;
    SPPRE1 = 2;

    /* [6:5] : 00, polling mode
    * [4]   : 1 = enable 
    * [3]   : 1 = master
    * [2]   : 0
    * [1]   : 0 = format A
    * [0]   : 0 = normal mode
    */
    SPCON0 = (1<<4) | (1<<3);
    SPCON1 = (1<<4) | (1<<3);

}

傳送資料時,先檢查狀態暫存器,判斷髮送/接收資料是否準備好了,準備好後就把資料放在暫存器SPTDAT1裡,SPI控制器就自己控制時序把資料自動傳送出去了。

void SPISendByte(unsigned char val)
{
    while (!(SPSTA1 & 1));
    SPTDAT1 = val;    
}

接收資料時,先寫0xFF到暫存器SPTDAT1,再檢查狀態暫存器,判斷髮送/接收資料是否準備好了,準備好後就讀取暫存器SPTDAT1,讀取出來的就是接收到的資料。

unsigned char SPIRecvByte(void)
{
    SPTDAT1 = 0xff;    
    while (!(SPSTA1 & 1));
    return SPRDAT1;    
}

第007節_移植到MINI2440_TQ2440

前面在JZ2440上操作了SPI Flash和OLED,這節視訊是件前面的程式碼移植到MINI2440和TQ2440上,如果你使用的是JZ2440,本節視訊就不用看了。

MINI2440和TQ2440上的SPI管腳是完全一樣的,因此只需移植一個,兩者就通用了,先移植GPIO模式版本的,複製前面 04th_spi_i2c_adc_jz2440_ok_020_005 裡的程式碼,複製後的新的命名為 06th_spi_i2c_adc_mini2440_tq2440_gpio_020_007 。

修改 gpio_spi.c ,裡面的管腳幾乎都變化了,因此需要改 SPI_GPIO_Init() :

static void SPI_GPIO_Init(void)
{
    /* GPG1 OLED_CSn output 
    * GPG10 FLASH_CSn output
    */
    GPGCON &= ~((3<<(1*2)) | (3<<(10*2)));
    GPGCON |= (1<<(1*2)) | (1<<(10*2));
    GPGDAT |= (1<<1) | (1<<10);

    /* 
    * GPF3  OLED_DC   output
    * GPE11 SPIMISO   input
    * GPE12 SPIMOSI   output
    * GPE13 SPICLK    output
    */
    GPFCON &= ~(3<<(3*2));    
    GPFCON |= (1<<(3*2));    

    GPECON &= ~((3<<(11*2)) | (3<<(12*2)) | (3<<(13*2)));
    GPECON |= ((1<<(12*2)) | (1<<(13*2)));
}

CLK引腳也變了,修改如下:

static void SPI_Set_CLK(char val)
{
    if (val)
        GPEDAT |= (1<<13);
    else
        GPEDAT &= ~(1<<13);
}

SPI的MOSI和MISO也要變化如下:

static void SPI_Set_DO(char val)
{
    if (val)
        GPEDAT |= (1<<12);
    else
        GPEDAT &= ~(1<<12);
}

static char SPI_Get_DI(void)
{
    if (GPEDAT & (1<<11))
        return 1;
    else 
        return 0;
}

對於SPI Flash需要修改其片選引腳,修改 spi_flash.c 裡面的片選函式如下:

static void SPIFlash_Set_CS(char val)
{
    if (val)
        GPGDAT |= (1<<10);
    else
        GPGDAT &= ~(1<<10);
}

重新編譯燒寫,測試正常。
再移植SPI控制器版本的,複製前面 05th_spi_i2c_adc_jz2440_spi_controller_020_006 裡的程式碼,複製後的新的命名為 07th_spi_i2c_adc_mini2440_tq2440_spi_controller_020_007 。
同樣的首先修改GPIO初始化,修改為配套引腳:

static void SPI_GPIO_Init(void)
{
    /* GPG1 OLED_CSn output 
    * GPG10 FLASH_CSn output
    */
    GPGCON &= ~((3<<(1*2)) | (3<<(10*2)));
    GPGCON |= (1<<(1*2)) | (1<<(10*2));
    GPGDAT |= (1<<1) | (1<<10);

    /* 
    * GPF3  OLED_DC   output
    * GPE11 SPIMISO   
    * GPE12 SPIMOSI   
    * GPE13 SPICLK    
    */
    GPFCON &= ~(3<<(3*2));    
    GPFCON |= (1<<(3*2));    

    GPECON &= ~((3<<(11*2)) | (3<<(12*2)) | (3<<(13*2)));
    GPECON |= ((2<<(11*2)) | (2<<(12*2)) | (2<<(13*2)));
}

SPI Flash使用的是SPI0,因此將 SPTDAT1 改為 SPTDAT1 :

void SPISendByte(unsigned char val)
{
    while (!(SPSTA0 & 1));
    SPTDAT0 = val;    
}

unsigned char SPIRecvByte(void)
{
    SPTDAT0 = 0xff;    
    while (!(SPSTA0 & 1));
    return SPRDAT0;    
}

修改SPI Flash的片選引腳:

static void SPIFlash_Set_CS(char val)
{
    if (val)
        GPGDAT |= (1<<10);
    else
        GPGDAT &= ~(1<<10);
}

最後是OLED的片選和資料/命令控制引腳:

static void OLED_Set_DC(char val)
{
    if (val)
        GPFDAT |= (1<<3);
    else
        GPFDAT &= ~(1<<3);
}

static void OLED_Set_CS(char val)
{
    if (val)
        GPGDAT |= (1<<1);
    else
        GPGDAT &= ~(1<<1);
}

重新編譯、燒寫,測試。