“第020课 SPI裸板”的版本间的差异

来自百问网嵌入式Linux wiki
第48行： 第48行：
 
<img src="./lesson/lesson1/lesson1_003.jpg">
 
<img src="./lesson/lesson1/lesson1_003.jpg">
 
SCLK的初始电平我们并不需要关心，只要保证在上升沿采样数据就行。
 
SCLK的初始电平我们并不需要关心，只要保证在上升沿采样数据就行。
 +
 +
=第002节_使用GPIO实现SPI协议操作OLED =
 +
现在开始写代码，使用GPIO实现SPI协议操作。
 +
我们现在想要操作OLED，通过三条线(SCK、DO、CS)与OLED相连，这里没有DI是因为2440只会向OLED传数据而不用接收数据。
 +
我们要用GPIO来实现SOC向OLED写数据，这一层用gpio_spi.c来实现，负责发送数据。
 +
对于OLED，有专门的指令和数据格式，要传输的数据内容，在oled.c这一层来实现，负责组织数据。
 +
因此，我们需要实现以上两个文件。
 +
<img src="./lesson/lesson2/lesson2_001.jpg">
 +
 +
需要实现的函数：先SPI初始化SPIInt()，再初始化OLEDOLEDInit()，最后再显示OLEDPrint()。
 +
 +
新建一个gpio_spi.c文件，实现SPI初始化SPIInt()
 +
 +
<syntaxhighlight lang="c" >
 +
void SPIInit(void)
 +
{
 +
    /* 初始化引脚 */
 +
    SPI_GPIO_Init();
 +
}
 +
</syntaxhighlight>
 +
 +
再具体实现SPI_GPIO_Init()。这里使用GPIO实现SPI协议，电路图如下：
 +
<img src="./lesson/lesson2/lesson2_002.jpg">
 +
GPF1作为OLED片选引脚，设置为输出；
 +
GPG2作为FLASH片选引脚，设置为输出；
 +
GPG4作为OLED的数据(Data)/命令(Command)选择引脚，设置为输出；
 +
GPG5作为SPI的MISO，设置为输入；
 +
GPG6作为SPI的MOSI，设置为输出；
 +
GPG7作为SPI的时钟CLK，设置为输出；
 +
 +
<syntaxhighlight lang="c" >
 +
/* 用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);
 +
}
 +
 +
</syntaxhighlight>
 +
 +
再新建一个oled.c文件，以实现初始化OLEDOLEDInit()
 +
 +
<syntaxhighlight lang="c" >
 +
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);
 +
}
 +
</syntaxhighlight>
 +
 +
因此我们还要先实现OLEDWriteCmd()函数，对于OLED，除了SPI的片选、时钟、数据引脚，还有一个数据/命令切换引脚。
 +
<img src="./lesson/lesson2/lesson2_003.jpg">
 +
这里的D/C即数据(Data)/命令(Command)选择引脚，它为高电平时，OLED即认为收到的是数据；它为低电平时，OLED即认为收到的是命令。
 +
对于OLED，命令由开启/关闭显示、背光亮度等，具体有什么命令，可以查阅OLED的主控芯片手册SSD1306-Revision 1.1 (Charge Pump).pdf，在9 COMMAND TABLE 有相关命令的介绍。
 +
因此，在编写OLEDWriteCmd()时，需要先设置为命令模式：
 +
<syntaxhighlight lang="c" >
 +
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); /*  */
 +
}
 +
</syntaxhighlight>
 +
即：先设置为命令模式，再片选OLED，再传输命令，再恢复成原来的模式和取消片选。
 +
 +
片选函数和模式切换函数都比较简单，设置为对应的高低电平即可：
 +
 +
<syntaxhighlight lang="c" >
 +
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);
 +
}
 +
 +
 +
</syntaxhighlight>
 +
还剩下SPISendByte()函数，它属于SPI协议，放在gpio_spi.c里面：
 +
<syntaxhighlight lang="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;
 +
    }
 +
   
 +
}
 +
</syntaxhighlight>
 +
发送数据要满足SPI的时序要求，参考前面的介绍：
 +
<img src="./lesson/lesson1/lesson1_002.jpg">
 +
先设置CLK为低，然后数据引脚输出数据的最高位，然后CLK为高，在CLK这个上升沿中,OLED就读取了一位数据。接着左移一位，将原来的第7位移动到了第8位，重复8次，传输完成。
 +
 +
再完成SPI_Set_CLK()和SPI_Set_DO()：
 +
<syntaxhighlight lang="c" >
 +
 +
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);
 +
}
 +
 +
 +
</syntaxhighlight>
 +
至此，SPI初始化和OLED初始化就基本完成了，接下来就是OLED显示部分。
 +
先了解一下OLED显示的原理：
 +
<img src="./lesson/lesson2/lesson2_004.jpg">
 +
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)。
 +
<syntaxhighlight lang="c" >
 +
/* 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++;
 +
    }
 +
}
 +
</syntaxhighlight>
 +
只要字符数组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位数据。
 +
<img src="./lesson/lesson2/lesson2_005.jpg">
 +
<syntaxhighlight lang="c" >
 +
 +
/* 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]);
 +
}
 +
</syntaxhighlight>
 +
显示一个字符，就先获取字模数据，接着发出8字节数据，再换行发出8字节数。
 +
 +
再来实现OLED设置坐标位置函数，先设置page：
 +
<img src="./lesson/lesson2/lesson2_006.jpg">
 +
D0~D2表示page数据，D3-D7是固定的值，因此每次写的命令内容为0xB0+page;
 +
 +
再设置列：
 +
<img src="./lesson/lesson2/lesson2_007.jpg">
 +
分两次发送，显示发送低字节4位，再发送高字节四位；
 +
<syntaxhighlight lang="c" >
 +
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 */
 +
}
 +
</syntaxhighlight>
 +
 +
前面提到了OLED主控有三种地址模式，我们常用的是页地址模式(Page addressing mode (A[1:0]=10xb))，虽然这是默认的摸索，但还是设置一下比较好：
 +
<img src="./lesson/lesson2/lesson2_008.jpg">
 +
即先发送0x20，再设置A[1:0]=10：
 +
<syntaxhighlight lang="c" >
 +
static void OLEDSetPageAddrMode(void)
 +
{
 +
    OLEDWriteCmd(0x20);
 +
    OLEDWriteCmd(0x02);
 +
}
 +
 +
</syntaxhighlight>
 +
在显示中，一般都需一个清屏函数来清空当前可能显示的数据。清屏函数比较简单，往所有位置里面写0即可：
 +
<syntaxhighlight lang="c" >
 +
static void OLEDClear(void)
 +
{
 +
    int page, i;
 +
    for (page = 0; page < 8; page ++)
 +
    {
 +
        OLEDSetPos(page, 0);
 +
        for (i = 0; i < 128; i++)
 +
            OLEDWriteDat(0);
 +
    }
 +
}
 +
</syntaxhighlight>
 +
 +
再把地址模式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:
 +
<img src="./lesson/lesson3/lesson3_001.jpg">
 +
 +
<syntaxhighlight lang="c" >
 +
void SPIFlashReadID(int *pMID, int *pDID)
 +
{
 +
    SPIFlash_Set_CS(0); /* 选中SPI FLASH */
 +
 +
    SPISendByte(0x90);
 +
 +
    SPIFlashSendAddr(0);
 +
 +
    *pMID = SPIRecvByte();
 +
    *pDID = SPIRecvByte();
 +
 +
    SPIFlash_Set_CS(1);
 +
}
 +
</syntaxhighlight>
 +
把其中的发送24地址封装成了一个函数 SPIFlashSendAddr() :
 +
<syntaxhighlight lang="c" >
 +
static void SPIFlashSendAddr(unsigned int addr)
 +
{
 +
    SPISendByte(addr >> 16);
 +
    SPISendByte(addr >> 8);
 +
    SPISendByte(addr & 0xff);
 +
}
 +
</syntaxhighlight>
 +
 +
依次完成上面的子函数，先是SPI片选，上一节的原理图可以看到SPI Flash的片选是GPG2:
 +
<syntaxhighlight lang="c" >
 +
static void SPIFlash_Set_CS(char val)
 +
{
 +
    if (val)
 +
        GPGDAT |= (1<<2);
 +
    else
 +
        GPGDAT &= ~(1<<2);
 +
}
 +
 +
</syntaxhighlight>
 +
 +
SPISendByte() 和前面OLED的是一样的，就不用写了，因此就只剩下 SPIRecvByte() ，放在 gpio_spi.c 里面实现：
 +
 +
<syntaxhighlight lang="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;   
 +
}
 +
 +
</syntaxhighlight>
 +
 +
在每个时钟周期读取DI引脚上的值，对于SOC就是MISO引脚：
 +
<syntaxhighlight lang="c" >
 +
static char SPI_Get_DI(void)
 +
{
 +
    if (GPGDAT & (1<<5))
 +
        return 1;
 +
    else
 +
        return 0;
 +
}
 +
</syntaxhighlight>
 +
 +
至此，读取Flash的ID基本实现，最后在主函数里调用打印，分别在串口和OLED上显示：
 +
<syntaxhighlight lang="c" >
 +
 +
    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);
 +
</syntaxhighlight>
 +
 +
Makefile记得加上新生成的 spi_flash.o 。
 +
 +
 +
  
 
='''《《所有章节目录》》'''=
 
='''《《所有章节目录》》'''=
 
<categorytree mode=all background*color:white;">ARM裸机加强版</categorytree>
 
<categorytree mode=all background*color:white;">ARM裸机加强版</categorytree>
 
[[Category:ARM裸机加强版 ]]
 
[[Category:ARM裸机加强版 ]]

2018年1月17日 (三) 17:32的版本

第001节_SPI协议介绍

  • 配套视频:ARM裸机1期加强版->第20课_SPI->第001节_SPI协议介绍_P.mp4
  • 配套代码:023_spi_020->01th_spi_i2c_adc_jz2440_oled_020_002
  • 配套笔记:
  • 实验环境:百问网Ubuntu16.04、Window7/Window10
  • 适用单板:JZ2440(原理适用所有Soc)

市面上的开发板很少接有SPI设备，但是SPI协议在工作中经常用到。我们开发了SPI模块，上面有SPI Flash和SPI OLED。OLED就是一块显示器。

我们裸板程序会涉及两部分：

  1. 用GPIO模拟SPI
  2. 用S3C2440的SPI控制器

我们先介绍下SPI协议，硬件框架如下： <img src="./lesson/lesson1/lesson1_001.jpg"> 

SCK：提供时钟
DO:作为数据输出
DI:作为数据输入
CS0/CS1:作为片选

同一时刻只能有一个SPI设备处于工作状态。

假设现在2440传输一个0x56数据给SPI Flash，时序如下： <img src="./lesson/lesson1/lesson1_002.jpg"> 首先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，查看它的芯片手册时序部分： <img src="./lesson/lesson1/lesson1_003.jpg"> SCLK的初始电平我们并不需要关心，只要保证在上升沿采样数据就行。

第002节_使用GPIO实现SPI协议操作OLED

现在开始写代码，使用GPIO实现SPI协议操作。 我们现在想要操作OLED，通过三条线(SCK、DO、CS)与OLED相连，这里没有DI是因为2440只会向OLED传数据而不用接收数据。 我们要用GPIO来实现SOC向OLED写数据，这一层用gpio_spi.c来实现，负责发送数据。 对于OLED，有专门的指令和数据格式，要传输的数据内容，在oled.c这一层来实现，负责组织数据。 因此，我们需要实现以上两个文件。 <img src="./lesson/lesson2/lesson2_001.jpg">

需要实现的函数：先SPI初始化SPIInt()，再初始化OLEDOLEDInit()，最后再显示OLEDPrint()。

新建一个gpio_spi.c文件，实现SPI初始化SPIInt() 

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

再具体实现SPI_GPIO_Init()。这里使用GPIO实现SPI协议，电路图如下： <img src="./lesson/lesson2/lesson2_002.jpg"> 

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的片选、时钟、数据引脚，还有一个数据/命令切换引脚。 <img src="./lesson/lesson2/lesson2_003.jpg"> 这里的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的时序要求，参考前面的介绍： <img src="./lesson/lesson1/lesson1_002.jpg"> 先设置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显示的原理： <img src="./lesson/lesson2/lesson2_004.jpg"> 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位数据。 <img src="./lesson/lesson2/lesson2_005.jpg"> 

/* 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： <img src="./lesson/lesson2/lesson2_006.jpg"> D0~D2表示page数据，D3-D7是固定的值，因此每次写的命令内容为0xB0+page;

再设置列： <img src="./lesson/lesson2/lesson2_007.jpg"> 分两次发送，显示发送低字节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))，虽然这是默认的摸索，但还是设置一下比较好： <img src="./lesson/lesson2/lesson2_008.jpg"> 即先发送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: <img src="./lesson/lesson3/lesson3_001.jpg"> 

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 。



《《所有章节目录》》

▼ ARM裸机加强版
  第001课 不要再用老方法学习单片机和ARM
  第002课 ubuntu环境搭建和ubuntu图形界面操作(免费)
  第003课 linux入门命令
  第004课 vi编辑器
  第005课 linux进阶命令
  第006课 开发板熟悉与体验(免费)
  第007课 裸机开发步骤和工具使用(免费))
  第008课 第1个ARM裸板程序及引申(部分免费)
  第009课 gcc和arm-linux-gcc和Makefile
  第010课 掌握ARM芯片时钟体系
  第011课 串口(UART)的使用
  第012课 内存控制器与SDRAM
  第013课 代码重定位
  第014课 异常与中断
  第015课 Nor Flash
  第016课 Nand Flash
  第017课 LCD编程
  第018课 ADC和触摸屏
  第019课 I2C
  第020课 SPI裸板
  第021课 MMU和Cache
  第022课 传感器
取自“http://wiki.100ask.org/index.php?title=第020课_SPI裸板&oldid=388”