【MM32F5270开发板试用】快速移植STM32应用到MM32F5270（以OLED为例）

本篇文章来自极术社区与灵动组织的MM32F5270开发板评测活动，更多开发板试用活动请关注极术社区网站。作者：@#@

本篇文章来自极术社区与灵动组织的MM32F5270开发板评测活动，更多开发板试用活动请关注极术社区网站。作者：@#@

最近在做几个嵌入式项目，一直使用的是STM32F429作为主控制芯片。从去年开始，ST的芯片全系涨价，价格高到离谱，并且市场上充斥着翻新芯片，有时候有钱都不一定能买到靠谱的原装芯片。考虑到项目最终落地需要考虑到芯片供应问题，所以一直在寻找国产替代。正好看到极术社区的MM32F5270适用活动，初步看芯片性能以及外设接口能满足现在的项目需求，所以申请一个板子来看下从STM32移植到MM32F5270的工作量。

一 项目简介

最近做的项目是一个气体分析仪，基本原理框图如下。

用STM32跑PID算法，控制比例阀开度，将输入气流稳定到设置值，然后由气体检测器进行采样并处理。这个项目目前已经开始小批量出货，这里就不过多说明技术细节。

由于项目客制化需求比较多，要求能够通过键盘选择不同功能，涉及到多级菜单。所以大量的工作都在自定义的菜单设计和实现上，这里就先试试移植OLED驱动代码到MM32F5270看看工作量。

二 环境准备

请参考https://aijishu.com/a/1060000…准备开发环境。记住，一定要下载MDK5.37版本才能使用灵动微电子的MM32 pack包。

因为我习惯用JLINK调试器做开发，所以这里我就直接使用JLINK作为调试工具。JLINK的插头直接插上去就可以，有防呆设计，不用担心会插错，下面是JLINK连接特写。

插上JLINK后，在魔术棒页面DEBUG tab里选择JLINK/J-TRACE Cortex

点击setting，在setting页面选择SW

接下来就可以愉快的使用JLINK进行MM32F5270开发板的调试了。

三 代码移植

初步看了下Mind SDK的文件结构，对所有的外设，都有对应的驱动代码，驱动代码对底层的硬件操作做了很好的封装。看了下对应的driver_example以及demo_apps,提供的都是类似于如下的代码文件组织结构

对于简单的应用来说，这种结构可以满足需求。但是对于一些外设较多的项目，这种组织形式在逻辑上不是很清晰，且代码复用性不高。所以这里按照项目的需求，设计了按hardware和module分类的方法，项目部分文件结构如下：

其中hardware目录是用到的外设driver，module目录里会放跟硬件无关的功能模块，比如流量控制功能，气体采样功能（当然目前为空，但是因为这是硬件无关逻辑，所以基本上可以不做改动直接移到MM32F5270）等。这里以tim_basic例程为基础，来移植OLED驱动。

1. 拆分clock_init.c/clock_init.h文件，这里将所有外设的clokc外设移除，只留下主时钟的初始化。
   void BOARD_InitBootClocks(void)
   {
   CLOCK_ResetToDefault();
   CLOCK_BootToHSE120MHz();
   }

2.将uart拆分到单独文件，以后在不同项目可以进行复用
demo_uart.h

#ifndef _UART_H_
#define _UART_H_

#include “clock_init.h”

/* DEBUG UART. */
#define BOARD_DEBUG_UART_PORT UART1
#define BOARD_DEBUG_UART_BAUDRATE 9600u
#define BOARD_DEBUG_UART_FREQ CLOCK_APB2_FREQ

void uart1_init(void);
#endif

demo_uart.c
#include “demo_uart.h”
#include

#include “hal_common.h”
#include “hal_gpio.h”
#include “hal_uart.h”
#include “hal_rcc.h”

static void uart1_gpio_init(void)
{
/* PB6 - UART1_TX. */
GPIO_Init_Type gpio_init;
gpio_init.Pins = GPIO_PIN_6;
gpio_init.PinMode = GPIO_PinMode_AF_PushPull;
gpio_init.Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &gpio_init);
GPIO_PinAFConf(GPIOB, gpio_init.Pins, GPIO_AF_7);

/* PB7 - UART1_RX. */
gpio_init.Pins = GPIO_PIN_7;
gpio_init.PinMode = GPIO_PinMode_In_Floating;
gpio_init.Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &gpio_init);
GPIO_PinAFConf(GPIOB, gpio_init.Pins, GPIO_AF_7);

}

static void uart1_port_init(void)
{
UART_Init_Type uart_init;

uart_init.ClockFreqHz = BOARD_DEBUG_UART_FREQ;
uart_init.BaudRate = BOARD_DEBUG_UART_BAUDRATE;
uart_init.WordLength = UART_WordLength_8b;
uart_init.StopBits = UART_StopBits_1;
uart_init.Parity = UART_Parity_None;
uart_init.XferMode = UART_XferMode_RxTx;
uart_init.HwFlowControl = UART_HwFlowControl_None;
UART_Init(BOARD_DEBUG_UART_PORT, &uart_init);
UART_Enable(BOARD_DEBUG_UART_PORT, true);

}

void uart1_init(void)
{
/* UART1. */
RCC_EnableAPB2Periphs(RCC_APB2_PERIPH_UART1, true);
RCC_ResetAPB2Periphs(RCC_APB2_PERIPH_UART1);

/* GPIOB. */
RCC_EnableAHB1Periphs(RCC_AHB1_PERIPH_GPIOB, true);
RCC_ResetAHB1Periphs(RCC_AHB1_PERIPH_GPIOB);

uart1_gpio_init();

uart1_port_init();
}

#if defined(__ARMCC_VERSION)
int fputc(int c, FILE *f)
{
(void)(f);
while ( 0u == (UART_STATUS_TX_EMPTY & UART_GetStatus(BOARD_DEBUG_UART_PORT)) )
{}
UART_PutData(BOARD_DEBUG_UART_PORT, (uint8_t)©);
return c;
}

int fgetc(FILE *f)
{
(void)(f);
while ( 0u == (UART_STATUS_RX_DONE & UART_GetStatus(BOARD_DEBUG_UART_PORT)) )
{}
return UART_GetData(BOARD_DEBUG_UART_PORT);
}

#elif defined(__GNUC__)

/*
* Called by libc stdio fwrite functions
*/
int _write(int fd, char *ptr, int len)
{
int i = 0;

/*
* write “len” of char from “ptr” to file id “fd”
* Return number of char written.
*
* Only work for STDOUT, STDIN, and STDERR
*/
if (fd > 2)
{
return -1;
}

while (*ptr && (i < len))
{
while ( 0u == (UART_STATUS_TX_EMPTY & UART_GetStatus(BOARD_DEBUG_UART_PORT)) )
{}
UART_PutData(BOARD_DEBUG_UART_PORT, (uint8_t)(*ptr));
i++;
ptr++;
}

return i;
}

/*
* Called by the libc stdio fread fucntions
*
* Implements a buffered read with line editing.
*/
int _read(int fd, char *ptr, int len)
{
int my_len;

if (fd > 2)
{
return -1;
}

my_len = 0;
while (len > 0)
{
while ( 0u == (UART_STATUS_RX_DONE & UART_GetStatus(BOARD_DEBUG_UART_PORT)) )
{}
*ptr = UART_GetData(BOARD_DEBUG_UART_PORT);
len–;
my_len++;

if ( (*ptr == ‘\r’) || (*ptr == ‘\n’) || (*ptr == ‘\0’) )
{
break;
}

ptr++;
}

return my_len; /* return the length we got */
}

int putchar(int c)
{
while ( 0u == (UART_STATUS_TX_EMPTY & UART_GetStatus(BOARD_DEBUG_UART_PORT)) )
{}
UART_PutData(BOARD_DEBUG_UART_PORT, (uint8_t)©);
return c;
}

int getchar(void)
{
while ( 0u == (UART_STATUS_RX_DONE & UART_GetStatus(BOARD_DEBUG_UART_PORT)) )
{}
return UART_GetData(BOARD_DEBUG_UART_PORT);
}

#elif (defined(__ICCARM__))
/* These function __write and __read is used to support IAR toolchain to printf and scanf. */

int fputc(int ch, FILE *f)
{
while ( 0u == (UART_STATUS_TX_EMPTY & UART_GetStatus(BOARD_DEBUG_UART_PORT)) )
{}
UART_PutData(BOARD_DEBUG_UART_PORT, (uint8_t)(ch));
return ch;
}

int fgetc(FILE *f)
{
while ( 0u == (UART_STATUS_RX_DONE & UART_GetStatus(BOARD_DEBUG_UART_PORT)) )
{}
return UART_GetData(BOARD_DEBUG_UART_PORT);
}

#endif

1. OLED会用到SPI，这里用SPI3作为控制接口
   demo_spi.h

   #ifndef _DEMO_SPI_H_
   #define _DEMO_SPI_H_
   #include “hal_common.h”
   #include “clock_init.h”

   #define BOARD_LOOP_SPI_PORT SPI3
   //#define BOARD_LOOP_SPI_BAUDRATE 1000000u /* 400khz. /
   #define BOARD_LOOP_SPI_BAUDRATE 400000u / 400khz. */

   #define BOARD_LOOP_SPI_FREQ CLOCK_APB1_FREQ

   void spi3_init(void);

   /* SPI tx. */
   void spi3_putbyte(uint8_t c);

   /* SPI rx. */
   uint8_t spi3_getbyte(void);
   #endif

2. demo_spi.c

   #include “demo_spi.h”
   #include “hal_rcc.h”
   #include “hal_spi.h”
   #include “hal_gpio.h”

   static void spi3_gpio_init(void)
   {
   GPIO_Init_Type gpio_init;

   /* SPI3_NSS - PA15. /
   /
   gpio_init.Pins = GPIO_PIN_15;
   gpio_init.PinMode = GPIO_PinMode_AF_PushPull;
   gpio_init.Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOA, &gpio_init);
   GPIO_PinAFConf(GPIOA, GPIO_PIN_15, GPIO_AF_6);
   */

   /* SPI3_MOSI - PC12. */
   gpio_init.Pins = GPIO_PIN_12;
   gpio_init.PinMode = GPIO_PinMode_AF_PushPull;
   gpio_init.Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOC, &gpio_init);
   GPIO_PinAFConf(GPIOC, GPIO_PIN_12, GPIO_AF_6);

   /* SPI3_MISO - PC11. */
   gpio_init.Pins = GPIO_PIN_11;
   gpio_init.PinMode = GPIO_PinMode_In_Floating;
   gpio_init.Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOC, &gpio_init);
   GPIO_PinAFConf(GPIOC, GPIO_PIN_11, GPIO_AF_6);

   /* SPI3_SCK - PC10. */
   gpio_init.Pins = GPIO_PIN_10;
   gpio_init.PinMode = GPIO_PinMode_AF_PushPull;
   gpio_init.Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOC, &gpio_init);
   GPIO_PinAFConf(GPIOC, GPIO_PIN_10, GPIO_AF_6);

   }

   static void spi3_port_init(void)
   {
   /* Setup SPI module. */
   SPI_Master_Init_Type spi_init;
   spi_init.ClockFreqHz = BOARD_LOOP_SPI_FREQ;
   spi_init.BaudRate = BOARD_LOOP_SPI_BAUDRATE;
   spi_init.XferMode = SPI_XferMode_TxRx;
   spi_init.PolarityPhase = SPI_PolarityPhase_Alt0;
   spi_init.DataWidth = SPI_DataWidth_8b;
   spi_init.LSB = false;
   spi_init.CSMode = SPI_CSMode_NonAuto;
   SPI_InitMaster(BOARD_LOOP_SPI_PORT, &spi_init);

   /* Enable SPI. */
   SPI_Enable(BOARD_LOOP_SPI_PORT, true);

   }

   void spi3_init(void)
   {
   /* GPIOA. /
   /
   RCC_EnableAHB1Periphs(RCC_AHB1_PERIPH_GPIOA, true);
   RCC_ResetAHB1Periphs(RCC_AHB1_PERIPH_GPIOA);
   */

   /* GPIOC. */
   RCC_EnableAHB1Periphs(RCC_AHB1_PERIPH_GPIOC, true);
   RCC_ResetAHB1Periphs(RCC_AHB1_PERIPH_GPIOC);

   /* SPI3. */
   RCC_EnableAPB1Periphs(RCC_APB1_PERIPH_SPI3, true);
   RCC_ResetAPB1Periphs(RCC_APB1_PERIPH_SPI3);

   spi3_gpio_init();
   spi3_port_init();
   }

   /* SPI tx. */
   void spi3_putbyte(uint8_t c)
   {
   /* Polling for tx empty. */
   while ( SPI_STATUS_TX_FULL & SPI_GetStatus(BOARD_LOOP_SPI_PORT) )
   {}
   SPI_PutData(BOARD_LOOP_SPI_PORT, c);
   }

   /* SPI rx. */
   uint8_t spi3_getbyte(void)
   {
   /* Polling for rx done. */
   while (0u == (SPI_STATUS_RX_DONE & SPI_GetStatus(BOARD_LOOP_SPI_PORT)) )
   {}
   return SPI_GetData(BOARD_LOOP_SPI_PORT);
   }

3. 顺便将LED4， LED5的控制单独拉出，可以作为debug的辅助手段
   led.h
   #ifndef _LED_H_
   #define _LED_H_

   #include “type_def.h”

   enum LED_NUM {
   LED4,
   LED5,
   };

   void led_init(void);

   void led_on(u8 led);

   void led_off(u8 led);
   #endif

4. led.c
   #include “led.h”
   #include “hal_rcc.h”
   #include “hal_gpio.h”

   static void led_gpio_init(void)
   {
   GPIO_Init_Type gpio_init;

   /* LED4. */
   gpio_init.Pins = GPIO_PIN_0;
   gpio_init.PinMode = GPIO_PinMode_Out_PushPull;
   gpio_init.Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOI, &gpio_init);

   /* LED5. */
   gpio_init.Pins = GPIO_PIN_2;
   gpio_init.PinMode = GPIO_PinMode_Out_PushPull;
   gpio_init.Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOD, &gpio_init);

   }

   void led_init(void)
   {
   /* GPIOD. */
   RCC_EnableAHB1Periphs(RCC_AHB1_PERIPH_GPIOD, true);
   RCC_ResetAHB1Periphs(RCC_AHB1_PERIPH_GPIOD);

   /* GPIOI. */
   RCC_EnableAHB1Periphs(RCC_AHB1_PERIPH_GPIOI, true);
   RCC_ResetAHB1Periphs(RCC_AHB1_PERIPH_GPIOI);

   led_gpio_init();

   }

   void led_on(u8 led)
   {
   switch (led) {
   case LED4:
   GPIO_WriteBit(GPIOI, GPIO_PIN_0, 0u);
   break;
   case LED5:
   GPIO_WriteBit(GPIOD, GPIO_PIN_2, 0u);
   break;
   default:
   break;
   }
   }

   void led_off(u8 led)
   {
   switch (led) {
   case LED4:
   GPIO_WriteBit(GPIOI, GPIO_PIN_0, 1u);
   break;
   case LED5:
   GPIO_WriteBit(GPIOD, GPIO_PIN_2, 1u);
   break;
   default:
   break;
   }
   }

5. 以上完成后，OLED驱动移植的前期准备工作已经完成，现在开始将STM32上的OLED控制代码移到MM32F5270上来。OLED使用的是中景园的3.12寸 256X64 单色OLED屏幕，淘宝连接https://item.taobao.com/item…。
   控制引脚如图所示

原始STM32控制代码如下所示：
stm32的oled.h

#ifndef __OLED_H
#define __OLED_H 

#include "sys.h"

#define OLED_USE_SOFT_SPI 0


#define OLED_CS_Pin GPIO_PIN_12
#define OLED_CS_GPIO_Port GPIOH
#define OLED_DC_Pin GPIO_PIN_12
#define OLED_DC_GPIO_Port GPIOB
#define OLED_RES_Pin GPIO_PIN_11
#define OLED_RES_GPIO_Port GPIOH

#if OLED_USE_SOFT_SPI
#define SOFT_SPI_MOSI_Pin GPIO_PIN_7
#define SOFT_SPI_MOSI_GPIO_Port GPIOF
#define SOFT_SPI_MISO_Pin GPIO_PIN_8
#define SOFT_SPI_MISO_GPIO_Port GPIOF
#define SOFT_SPI_SCK_Pin GPIO_PIN_9
#define SOFT_SPI_SCK_GPIO_Port GPIOF
#endif

#define USE_HORIZONTAL 1  //设置显示方向 0：正向显示；1：旋转180度显示

#ifndef PIN_RESET
#define PIN_RESET 0
#define PIN_SET 1
#endif

void OLED_WR_REG(u8 reg);
void OLED_WR_Byte(u8 dat);
void Column_Address(u8 a,u8 b);
void Row_Address(u8 a,u8 b);
void OLED_Fill(u16 xstr,u8 ystr,u16 xend,u8 yend,u8 color);
void OLED_ShowChinese(u8 x,u8 y,u8 *s,u8 sizey,u8 mode);
void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 sizey,u8 mode);
void OLED_ShowString(u8 x,u8 y,u8 *dp,u8 sizey,u8 mode);
u32 oled_pow(u8 m,u8 n);
void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 sizey,u8 mode);
void OLED_DrawBMP(u8 x,u8 y,u16 length,u8 width,const u8 BMP[],u8 mode);
void OLED_DrawSingleBMP(u8 x,u8 y,u16 length,u8 width,const u8 BMP[],u8 mode);
void OLED_Init(void);

void OLED_GPIO_Init(void);

#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

stm32的oled.c

#include "oledfont.h"
#include "delay.h"
#include "oled.h"
#include "osal.h"
#include "spi.h"

#if OLED_USE_SOFT_SPI
static void OLED_SCL_Clr()
{
    HAL_GPIO_WritePin(SOFT_SPI_SCK_GPIO_Port, SOFT_SPI_SCK_Pin, GPIO_PIN_RESET); //SCL
}

static void OLED_SCL_Set()
{
    HAL_GPIO_WritePin(SOFT_SPI_SCK_GPIO_Port, SOFT_SPI_SCK_Pin, GPIO_PIN_SET);
}

static void OLED_SDA_Clr()
{
    HAL_GPIO_WritePin(SOFT_SPI_MOSI_GPIO_Port, SOFT_SPI_MOSI_Pin, GPIO_PIN_RESET); //SDA
}

static void OLED_SDA_Set()
{
    HAL_GPIO_WritePin(SOFT_SPI_MOSI_GPIO_Port, SOFT_SPI_MOSI_Pin, GPIO_PIN_SET);
}
#endif

static void OLED_RES_Clr()
{
    HAL_GPIO_WritePin(OLED_RES_GPIO_Port, OLED_RES_Pin, GPIO_PIN_RESET); //RES
}

static void OLED_RES_Set()
{
    HAL_GPIO_WritePin(OLED_RES_GPIO_Port, OLED_RES_Pin, GPIO_PIN_SET);
}

static void OLED_DC_Clr()
{
    HAL_GPIO_WritePin(OLED_DC_GPIO_Port, OLED_DC_Pin, GPIO_PIN_RESET); //DC
}

static void OLED_DC_Set()
{
    HAL_GPIO_WritePin(OLED_DC_GPIO_Port, OLED_DC_Pin, GPIO_PIN_SET);
}

static void OLED_CS_Clr()
{
    HAL_GPIO_WritePin(OLED_CS_GPIO_Port, OLED_CS_Pin, GPIO_PIN_RESET); //CS
}

static void OLED_CS_Set()
{
    HAL_GPIO_WritePin(OLED_CS_GPIO_Port, OLED_CS_Pin, GPIO_PIN_SET);
}

static void OLED_Write_Byte(u8 dat)
{
#if OLED_USE_SOFT_SPI
    u8 i;
    for(i=0;i<8;i++)
    {              
        OLED_SCL_Clr();
        //delay_us(200);
        if(dat&0x80)
        {
           OLED_SDA_Set();
        }
        else 
        {
           OLED_SDA_Clr();
        }
        //delay_us(20);
        OLED_SCL_Set();
        //delay_us(200);
        dat<<=1;   
    }
#else
    SPI_Write_Byte(2, dat);             
#endif
}

void OLED_WR_Bus(u8 dat)
{
    OLED_CS_Clr();
    OLED_Write_Byte(dat);          
    OLED_CS_Set();
}

void OLED_WR_REG(u8 reg)
{      
    OLED_DC_Clr();          
  OLED_WR_Bus(reg);
  OLED_DC_Set();    
}

void OLED_WR_Byte(u8 dat)
{      
  OLED_WR_Bus(dat);
}

void Column_Address(u8 a,u8 b)
{
    OLED_WR_REG(0x15);       // Set Column Address
    OLED_WR_Byte(0x1c+a);
    OLED_WR_Byte(0x1c+b);
}

void Row_Address(u8 a,u8 b)
{
    OLED_WR_REG(0x75);       // Row Column Address
    OLED_WR_Byte(a);
    OLED_WR_Byte(b);
    OLED_WR_REG(0x5C);    //写RAM命令
}

void OLED_Fill(u16 xstr,u8 ystr,u16 xend,u8 yend,u8 color)
{
    u8 x,y;
    xstr/=4;
    xend/=4;
    Column_Address(xstr,xend-1);
    Row_Address(ystr,yend-1);
    for(x=xstr;x

#ifndef __OLED_H
#define __OLED_H 

#include "type_def.h"

#define USE_HORIZONTAL 1  //设置显示方向 0：正向显示；1：旋转180度显示

#define OLED_USE_SOFT_SPI 0


void OLED_control_gpio_init(void);

void OLED_WR_REG(u8 reg);
void OLED_WR_Byte(u8 dat);
void Column_Address(u8 a,u8 b);
void Row_Address(u8 a,u8 b);
void OLED_Fill(u16 xstr,u8 ystr,u16 xend,u8 yend,u8 color);
void OLED_ShowChinese(u8 x,u8 y,u8 *s,u8 sizey,u8 mode);
void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 sizey,u8 mode);
void OLED_ShowString(u8 x,u8 y,u8 *dp,u8 sizey,u8 mode);
u32 oled_pow(u8 m,u8 n);
void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 sizey,u8 mode);
void OLED_DrawBMP(u8 x,u8 y,u16 length,u8 width,const u8 BMP[],u8 mode);
void OLED_DrawSingleBMP(u8 x,u8 y,u16 length,u8 width,const u8 BMP[],u8 mode);
void OLED_Init(void);

#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include "oledfont.h"
#include "delay.h"
#include "oled.h"
#include "demo_spi.h"
#include "hal_rcc.h"
#include "hal_gpio.h"
#include "stdio.h"

~~*void OLEDcontrolgpioinit(void)
{
    //GPIOA
    RCCEnableAHB1Periphs(RCCAHB1PERIPHGPIOA, true);
    RCCResetAHB1Periphs(RCCAHB1PERIPHGPIOA);
#if OLEDUSESOFTSPI
    RCCEnableAHB1Periphs(RCCAHB1PERIPHGPIOC, true);
    RCCResetAHB1Periphs(RCCAHB1PERIPHGPIOC);
#endif

    GPIOInitType gpioinit;

    //RES PA10
    gpioinit.Pins  = GPIOPIN10;
    gpioinit.PinMode  = GPIOPinModeOutPushPull;
    gpioinit.Speed = GPIOSpeed50MHz;
    GPIOInit(GPIOA, &gpioinit);

    //DC PA12
    gpioinit.Pins  = GPIOPIN12;
    gpioinit.PinMode  = GPIOPinModeOutPushPull;
    gpioinit.Speed = GPIOSpeed50MHz;
    GPIOInit(GPIOA, &gpioinit);

    //CS PA15
    gpioinit.Pins  = GPIOPIN15;
    gpioinit.PinMode  = GPIOPinModeOutPushPull;
    gpioinit.Speed = GPIOSpeed50MHz;
    GPIOInit(GPIOA, &gpioinit);

#if OLEDUSESOFTSPI
    //soft SCL PC10
    gpioinit.Pins  = GPIOPIN10;
    gpioinit.PinMode  = GPIOPinModeOutPushPull;
    gpioinit.Speed = GPIOSpeed50MHz;
    GPIOInit(GPIOC, &gpioinit);

    //soft MOSI PC12
    gpioinit.Pins  = GPIOPIN12;
    gpioinit.PinMode  = GPIOPinModeOutPushPull;
    gpioinit.Speed = GPIOSpeed50MHz;
    GPIOInit(GPIOC, &gpioinit);
#endif

}

#if OLEDUSESOFTSPI
static void OLEDSOFTSPISCKClr()
{
    GPIOWriteBit(GPIOC, GPIOPIN10, 0u); //RES
}

static void OLEDSOFTSPISCKSet()
{
    GPIOWriteBit(GPIOC, GPIOPIN10, 1u); //RES
}

static void OLEDSOFTSPISDAClr()
{
    GPIOWriteBit(GPIOC, GPIOPIN12, 0u); //RES
}


static void OLEDSOFTSPISDASet()
{
    GPIOWriteBit(GPIOC, GPIOPIN12, 1u); //RES
}

#endif
static void OLEDRESClr()
{
    GPIOWriteBit(GPIOA, GPIOPIN10, 0u); //RES
}

static void OLEDRESSet()
{
    GPIOWriteBit(GPIOA, GPIOPIN10, 1u); //RES
}

static void OLEDDCClr()
{
    GPIOWriteBit(GPIOA, GPIOPIN12, 0u); //RES
}

static void OLEDDCSet()
{
    GPIOWriteBit(GPIOA, GPIOPIN12, 1u); //RES
}

static void OLEDCSClr()
{
    GPIOWriteBit(GPIOA, GPIOPIN15, 0u); //RES
}*~~

static void OLED_CS_Set()
{
    GPIO_WriteBit(GPIOA, GPIO_PIN_15, 1u); //RES
}

static void OLED_Write_Byte(u8 dat)
{
#if OLED_USE_SOFT_SPI
    u8 i;
    for(i=0;i<8;i++)
    {              
        OLED_SOFT_SPI_SCK_Clr();
        //delay_us(20);
        if(dat&0x80)
        {
           OLED_SOFT_SPI_SDA_Set();
        }
        else 
        {
           OLED_SOFT_SPI_SDA_Clr();
        }
        //delay_us(20);
        OLED_SOFT_SPI_SCK_Set();
        //delay_us(200);
        dat<<=1;   
    }
#else
    spi3_putbyte(dat);
#endif
}

void OLED_WR_Bus(u8 dat)
{
    OLED_CS_Clr();
    OLED_Write_Byte(dat);
    OLED_CS_Set();
}

void OLED_WR_REG(u8 reg)
{      
    OLED_DC_Clr();          
    OLED_WR_Bus(reg);
    OLED_DC_Set();    
}

void OLED_WR_Byte(u8 dat)
{      
  OLED_WR_Bus(dat);
}

void Column_Address(u8 a,u8 b)
{
    OLED_WR_REG(0x15);       // Set Column Address
    OLED_WR_Byte(0x1c+a);
    OLED_WR_Byte(0x1c+b);
}

void Row_Address(u8 a,u8 b)
{
    OLED_WR_REG(0x75);       // Row Column Address
    OLED_WR_Byte(a);
    OLED_WR_Byte(b);
    OLED_WR_REG(0x5C);    //写RAM命令
}

void OLED_Fill(u16 xstr,u8 ystr,u16 xend,u8 yend,u8 color)
{
    u8 x,y;
    xstr/=4;
    xend/=4;
    Column_Address(xstr,xend-1);
    Row_Address(ystr,yend-1);
    for(x=xstr;x