第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顯示的原理：

[圖片上傳失敗...(image-1116a6-1520387876874)]

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 $(shell dirname $(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);
}

重新編譯、燒寫，測試。