#include "oled12864_drv.h"
#include "oled_font.h"


//#define _FONT_LIBRARY		// 是否使用外带字库

#ifdef _FONT_LIBRARY
	#include "gb2312_font.h"

#endif /* _FONT_LIBRARY */

/*
    OLED的显存
    存放格式如下：
    [0]0 1 2 3 ... 127
    [1]0 1 2 3 ... 127
    [2]0 1 2 3 ... 127
    [3]0 1 2 3 ... 127
    [4]0 1 2 3 ... 127
    [5]0 1 2 3 ... 127
    [6]0 1 2 3 ... 127
    [7]0 1 2 3 ... 127
*/

/************************************************
函数名称 ： OLED_Delay_us
功    能 ： 软件毫秒延时
参    数 ： Count ---- 次数
返 回 值 ： 无
*************************************************/
static void OLED_Delay_us( uint32_t Count )
{
    DelayUs(Count);
}

/************************************************
函数名称 ： OLED_Delay_ms
功    能 ： 软件毫秒延时
参    数 ： Count ---- 次数
返 回 值 ： 无
*************************************************/
static void OLED_Delay_ms( uint32_t Count )
{
    DelayMs(Count);
}


/************************************************
函数名称 ： OLED_Write_Cmd
功    能 ： OLED写命令
参    数 ： Cmd ---- 命令
返 回 值 ： 无
*************************************************/

void OLED_Write_Cmd( uint8_t Cmd )
{
	// IIC_Start();
	// IIC_SendByte(0x78);            // Slave address,SA0 = 0
    // IIC_WaitAck();
	// IIC_SendByte(0x00);			 // write command
    // IIC_WaitAck();
	// IIC_SendByte(Cmd);
    // IIC_WaitAck();
	// IIC_Stop();
    IIC_WriteBytes(0x78, 0x00, &Cmd, 1);
}

/************************************************
函数名称 ： OLED_Write_Data
功    能 ： OLED写数据
参    数 ： Data ---- 数据
           Inverse ---- 反白显示使能
返 回 值 ： 无
*************************************************/
void OLED_Write_Data( uint8_t Data, uint8_t Inverse )
{
    uint8_t temp = 0;

    if(!Inverse)
    {
        temp = Data;
    }
    else
    {
        temp = ~Data;
    }

	// IIC_Start();
	// IIC_SendByte(0x78);           // Slave address,SA0 = 0
    // IIC_WaitAck();
	// IIC_SendByte(0x40);			// write data
    // IIC_WaitAck();
	// IIC_SendByte(temp);
    // IIC_WaitAck();
	// IIC_Stop();

    IIC_WriteBytes(0x78, 0x40, &temp, 1);
}

/************************************************
函数名称 ： OLED_Fill
功    能 ： OLED亮屏 / 清屏
参    数 ： Mode ---- 清除/显示(OLED_CLS or OLED_SHOW)
返 回 值 ： 无
*************************************************/
void OLED_Fill( uint8_t Mode )
{
    uint8_t y,x;

    for(y = 0;y < 8;y++)
    {
        OLED_Write_Cmd(0xB0 + y);               // 第 n页开始（0~7）
        OLED_Write_Cmd(0x10);                   // 设置显示位置 - 列高位第一个
        OLED_Write_Cmd(0x00);                   // 设置显示位置 - 列低位第一个
        for(x = 0;x < OLED_MAX_COLUMN;x++)
        {
            OLED_Write_Data(Mode, DISABLE); // Data = 0x00全屏灭，Data = 0xff全屏亮
        }
    }
}

/************************************************
函数名称 ： OLED_Row_Clear
功    能 ： OLED单行清除 / 显示
参    数 ： Row ---- 首行
            Amount ---- 行数
			Mode ---- 清除/显示(OLED_CLS or OLED_SHOW)
返 回 值 ： 无
*************************************************/
void OLED_Row_Clear( uint8_t Row, uint8_t Amount ,uint8_t Mode )
{
    uint8_t y,x;

    if(Row < 8)
    {
        for(y = 0;y < Amount;y++)
        {
            OLED_Write_Cmd(0xB0 + Row + y);         // 第 n页开始（0~7）
            OLED_Write_Cmd(0x10);                   // 设置显示位置 - 列高位第一个
            OLED_Write_Cmd(0x00);                   // 设置显示位置 - 列低位第一个
            for(x = 0;x < OLED_MAX_COLUMN;x++)
            {
                OLED_Write_Data(Mode, DISABLE);
            }
        }
    }
}

/************************************************
函数名称 ： OLED_Coord
功    能 ： OLED坐标显示
参    数 ： X ---- X轴
			Y ---- Y轴
返 回 值 ： 无
*************************************************/
void OLED_Coord( uint8_t X, uint8_t Y )
{
//    assert(X < X_WIDTH);
//    assert(Y < (Y_WIDTH >> 3));

    /* B0~B7:此命令仅适用于页面寻址模式 */
    OLED_Write_Cmd(0xB0 + Y);                   // 设置GDDRAM页面开始地址,(Page 0~ Page 7)为页面寻址模式

    /* 10~1F:此命令仅适用于页面寻址模式 */
    OLED_Write_Cmd(((X & 0xF0) >> 4) | 0x10);   // 页面寻址模式下设置列开始地址寄存器的高位

    /* 00~0F:此命令仅适用于页面寻址模式 */
    OLED_Write_Cmd((X & 0x0F) | 0x00);          // 页面寻址模式下设置列开始地址寄存器的低位
}

/************************************************
函数名称 ： OLED_ShowRoll
功    能 ： OLED内置滚动显示
参    数 ： Y ---- 起始行
            Line ---- 滚动行数 (0 ---> 取消滚动)
            Mode ---- 滚动模式（OLED_LEFT_ROLL or OLED_RIGHT_ROLL）
返 回 值 ： 无
*************************************************/
void OLED_ShowRoll( uint8_t Y, uint8_t Line, uint8_t Mode )
{
    if(Line > 0)
    {
        if(Mode == OLED_LEFT_ROLL)
        {
            OLED_Write_Cmd(OLED_LEFT_ROLL);     // 左滚动显示
        }
        else if(Mode == OLED_RIGHT_ROLL)
        {
            OLED_Write_Cmd(OLED_RIGHT_ROLL);    // 右滚动显示
        }
        else
        {
            return ;
        }
        OLED_Write_Cmd(0x00);                   // 虚拟字节设置，默认为0x00
        OLED_Write_Cmd(Y);                      // 定义开始页面地址
        OLED_Write_Cmd(0x07);                   // 帧频设置
        OLED_Write_Cmd(Y + (Line - 1));  		// 定义结束页面地址
        OLED_Write_Cmd(0x00);                   // 虚拟字节设置，默认为0x00
        OLED_Write_Cmd(0xFF);                   // 虚拟字节设置，默认为0xFF
        OLED_Write_Cmd(0x2F);                   // 激活滚动
    }
    else
    {
        OLED_Write_Cmd(0x2E);                   // 失能滚动
    }
}

/************************************************
函数名称 ： OLED_ShowChar
功    能 ： OLED字符显示
参    数 ： X ---- X轴
			Y ---- Y轴
            Char ---- 字符
            Size ---- 字体大小
            Inverse ---- 反白显示使能
返 回 值 ： 无
*************************************************/
void OLED_ShowChar( uint8_t X, uint8_t Y, uint8_t Char, uint8_t Size, uint8_t Inverse )
{
    uint8_t i;
	uint8_t value = 0;

    if(X <= OLED_MAX_COLUMN - 8 && (Y < (OLED_MAX_ROW >> 3)))
    {
		if(X >= 0 && Y >= 0)
		{
			value = Char - 32;                                          // 得到偏移值(偏移量32)

			if(Size == OLED_FONT_SIXTEEN)                               // 8x16
			{
				OLED_Coord(X, Y);
				for(i = 0;i < 8;i++)
				{
					OLED_Write_Data(F8x16[value][i], Inverse);      // 前八个数据
				}

				OLED_Coord(X, Y+1);
				for(i = 0;i < 8;i++)
				{
					OLED_Write_Data(F8x16[value][i + 8], Inverse);  // 后八个数据
				}
			}
			else if(Size == OLED_FONT_EIGHT)                           // 6x8
			{
				OLED_Coord(X, Y);
				for(i = 0;i < 6;i++)
				{
					OLED_Write_Data(F6x8[value][i], Inverse);
				}
				/* 清除剩下的两个 */
				OLED_Write_Data(0x00, Inverse);
				OLED_Write_Data(0x00, Inverse);
			}
		}
    }
}

/************************************************
函数名称 ： OLED_ShowString
功    能 ： OLED字符串显示
参    数 ： X ---- X轴
			Y ---- Y轴
            Len ---- 长度
            pChar ---- 数据
            Size ---- 字体大小
            Inverse ---- 反白（全行）显示使能
返 回 值 ： 无
*************************************************/
void OLED_ShowString( uint8_t X, uint8_t Y, const uint8_t *pChar, uint16_t Len, uint8_t Size, uint8_t Inverse )
{
    uint8_t i,j;
    uint8_t temp = 0;

    if(Inverse)
    {
        for(j = 0;j < (Size / 8);j++)
        {
            OLED_Coord(0, Y + j);
            for(i = 0;i < OLED_MAX_COLUMN;i++)
            {
                OLED_Write_Data(OLED_SHOW, DISABLE);    // OLED_CLS = 0x00全屏灭，OLED_SHOW = 0xff全屏亮
            }
        }
    }

    if(Len <= 16)
    {
        while(Len--)
        {
            if(X >= OLED_MAX_COLUMN - 8)
            {
                break;
            }
            OLED_ShowChar(X, Y, *pChar, Size, Inverse);
            X += 8;
            pChar++;
        }
    }
}

/************************************************
函数名称 ： OLED_ShowPrintf
功    能 ： OLED字符串输出（自动顶部对齐换行）
参    数 ： X ---- X轴
			Y ---- Y轴
            pChar ---- 数据
            Size ---- 字体大小
            Align ---- 对齐显示使能
            Inverse ---- 反白（单字体）显示使能
返 回 值 ： 无
*************************************************/
void OLED_ShowPrintf( uint8_t X, uint8_t Y, const uint8_t *pChar, uint8_t Size, uint8_t Align, uint8_t Inverse )
{
    uint8_t addr = 0;

    if(Align)
    {
        addr = X;		// 记录顶部对齐位置 
    }

	while(*pChar != '\0')
	{
		if(X >= OLED_MAX_COLUMN - 8)             // 列溢出
        {
            X = addr;                           // 对齐列地址
            Y += (Size >> 3);                   // 转到下一行
            if(Y >= (OLED_MAX_ROW >> 3))
            {
                break;                         // Y轴越界退出
            }
        }
        OLED_ShowChar(X, Y, *pChar, Size, Inverse);
		X += 8;
        pChar++;
	}
}

/************************************************
函数名称 ： OLED_Power
功    能 ： OLED幂计算
参    数 ： M ---- X轴
			N ---- Y轴
返 回 值 ： power ---- 幂
*************************************************/
uint32_t OLED_Power( uint8_t M, uint8_t N )
{
	uint32_t power = 1;

	while(N--)
    {
        power *= M;
    }

	return power;
}

/************************************************
函数名称 ： OLED_ShowNum
功    能 ： OLED数字显示（限正整数）
参    数 ： X ---- X轴
			Y ---- Y轴
            Num ---- 数字
            Len ---- 位数
            Size ---- 字体大小
			Prefix ---- 补零显示使能
            Inverse ---- 反白显示使能
返 回 值 ： 无
*************************************************/
void OLED_ShowNum( uint8_t X, uint8_t Y, uint32_t Num, uint8_t Len, uint8_t Size, uint8_t Prefix, uint8_t Inverse )
{
	char temp = 0;
	uint8_t t;
	uint8_t show = 0;

	for(t = 0;t < Len;t++)
	{
		temp = (Num / OLED_Power(10, Len - t - 1)) % 10;          // 提取每位数字

		if(!show && t < (Len - 1))
		{
			if(0 == temp)
			{
				if(Prefix)
					OLED_ShowChar(X + 8 *t, Y , '0', Size, Inverse);
				else
					OLED_ShowChar(X + 8 *t, Y , ' ', Size, Inverse);
				continue;
			}
            else
            {
                show = 1;
            }
		}
	 	OLED_ShowChar(X + 8 *t, Y, temp + '0', Size, Inverse);
	}
}

/************************************************
函数名称 ： OLED_ShowHex
功    能 ： OLED十六进制显示
参    数 ： X ---- X轴
			Y ---- Y轴
            Num ---- 数字（10进制）
            Size ---- 字体大小（固定宽度为 8像素）
            Prefix ---- 补零显示使能
            Inverse ---- 反白显示使能
返 回 值 ： 无
*************************************************/
void OLED_ShowHex( uint8_t X, uint8_t Y, uint32_t Num, uint8_t Size, uint8_t Prefix, uint8_t Inverse )
{
	uint8_t t,temp;
    uint8_t i = 0;
	uint8_t show = 0;

	for(t = 0;t < 4;t++)
	{
		temp = (uint8_t)(Num >> (12 - 4*t)) & 0x000F;          // 提取每位数字

		if(!show && t < 3)
		{
			if(0 == temp)
			{
                if(Prefix)
                {
                    OLED_ShowChar(X + 8 *i, Y , '0', Size, Inverse);
                    i++;
                }
				continue;
			}
            else
            {
                show = 1;
            }
		}
		switch(temp)
		{
			case  0: temp = '0'; break;
			case  1: temp = '1'; break;
			case  2: temp = '2'; break;
			case  3: temp = '3'; break;
			case  4: temp = '4'; break;
			case  5: temp = '5'; break;
			case  6: temp = '6'; break;
			case  7: temp = '7'; break;
			case  8: temp = '8'; break;
			case  9: temp = '9'; break;
			case 10: temp = 'A'; break;
			case 11: temp = 'B'; break;
			case 12: temp = 'C'; break;
			case 13: temp = 'D'; break;
			case 14: temp = 'E'; break;
			case 15: temp = 'F'; break;
		}

	 	OLED_ShowChar(X + 8 *i, Y, temp, Size, Inverse);
        i++;
	}
}

/************************************************
函数名称 ： OLED_ShowFloat
功    能 ： OLED可变精度小数显示
参    数 ： X ---- X轴
			Y ---- Y轴
            Num ---- 数字
            Accuracy ---- 精确位数
            Size ---- 字体大小
            Inverse ---- 反白显示使能
返 回 值 ： 无
*************************************************/
void OLED_ShowFloat( uint8_t X, uint8_t Y, float Num, uint8_t Accuracy, uint8_t Size, uint8_t Inverse )
{
	uint8_t i = 0;
    uint8_t j = 0;
	uint8_t t = 0;
    uint8_t temp = 0;
    uint16_t numel = 0;
    uint32_t integer = 0;
    float decimals = 0;


    /* 判断是否为负数 */
    if(Num < 0)
    {
        OLED_ShowChar(X, Y , '-', Size, Inverse);
        Num = 0 - Num;
        i++;
    }

    integer = (uint32_t)Num;
    decimals = Num - integer;

    /* 整数部分 */
    if(integer)
    {
        numel = integer;

		while(numel)                                                        // 获取整数位数
		{
			numel /= 10;
            j++;
		}
        i += (j - 1);
        for(temp = 0;temp < j;temp++)
        {
            OLED_ShowChar(X + 8 *(i - temp), Y, integer % 10 + '0', Size, Inverse);  // 显示整数部分
            integer /= 10;
        }
	}
    else
    {
		OLED_ShowChar(X + 8 *i, Y, temp + '0', Size, Inverse);
	}
    i++;

    /* 小数部分 */
    if(Accuracy)
    {
        OLED_ShowChar(X + 8 *i, Y , '.', Size, Inverse);                    // 显示小数点

        i++;
        for(t = 0;t < Accuracy;t++)
        {
            decimals *= 10;
            temp = (uint8_t)decimals;                                       // 提取每位小数
            OLED_ShowChar(X + 8 *(i + t), Y, temp + '0', Size, Inverse);
            decimals -= temp;
        }
    }

}

/************************************************
函数名称 ： OLED_ShowLanguage
功    能 ： OLED汉字显示(16x16) 不带字库的 
参    数 ： X ---- X轴
			Y ---- Y轴
            pArray ---- 数据
            Len ---- 字数长度
            Inverse ---- 反白显示使能
返 回 值 ： 无
*************************************************/

/*
    mode 0:使用 1级指针来访问二维数组
    mode 1:使用指向数组的指针来访问二维数组
*/
#define _OLED_ShowLanguage_MODE     0       // (0 or 1)

#if (0 == _OLED_ShowLanguage_MODE)
void OLED_ShowLanguage( uint8_t X, uint8_t Y, const uint8_t *pArray, uint16_t Len, uint8_t Inverse )

#elif (1 == _OLED_ShowLanguage_MODE)
void OLED_ShowLanguage( uint8_t X, uint8_t Y, const uint8_t (*pArray)[16], uint16_t Len, uint8_t Inverse )

#endif /* _OLED_ShowLanguage_MODE */
{
    uint8_t i,j;
    uint8_t q = 0;
    uint8_t temp = 0;
	uint8_t distribute_flag = 0;									// 文字平均分布标志 

    if(Len <= 8)
    {
        if(!X)		// 首位显示，自动平均分布 
        {
            switch(Len)
            {
                case 1:
                        temp = 56;          // OLED_MAX_COLUMN / 2 - 8 = 56
                        break;
                case 2:
                        temp = 32;          // (OLED_MAX_COLUMN - Len*16) / (Len + 1) = 32  Len = 2
                        break;
                case 3:
                        temp = 20;          // (OLED_MAX_COLUMN / 2 - 8) / 2 - 8 = 20
                        break;
                case 4:
                        temp = 13;          // (OLED_MAX_COLUMN - Len*16) / (Len + 1) = 12 .... 4   Len = 4
                        break;
                case 5:
                        temp = 8;           // ((OLED_MAX_COLUMN / 2 - 8) - ((Len - 1) / 2)*16) / ((Len - 1) / 2 + 1) = 8   Len = 5
                        break;
                case 6:
                        temp = 5;           // (OLED_MAX_COLUMN - Len*16) / (Len + 1) = 4 .... 4    Len = 6
                        break;
                case 7:
                        temp = 2;           // ((OLED_MAX_COLUMN / 2 - 8) / 2 - 8) / 2 - 8 = 2
                        break;
                case 8:
                        temp = 0;
                        break;
                default:
                        break;
            }
            X += temp;
            distribute_flag = 1; 
        }

        for(j = 0;j < Len;j++)
        {
            OLED_Coord(X, Y);
            for(i = 0;i < 16;i++)
            {

#if (0 == _OLED_ShowLanguage_MODE)
                OLED_Write_Data(*(pArray + 2*j*16 + i), Inverse);      // 前十六个数据

#elif (1 == _OLED_ShowLanguage_MODE)
                OLED_Write_Data(pArray[2*j][i], Inverse);       // 前十六个数据

#endif /* _OLED_ShowLanguage_MODE */
            }

            OLED_Coord(X, Y+1);
            for(i = 0;i < 16;i++)
            {

#if (0 == _OLED_ShowLanguage_MODE)
                OLED_Write_Data(*(pArray + 2*j*16 + 16 + i), Inverse);           // 后十六个数据

#elif (1 == _OLED_ShowLanguage_MODE)
                OLED_Write_Data(pArray[2*j + 1][i], Inverse);   // 后十六个数据

#endif /* _OLED_ShowLanguage_MODE */
            }
            X += (16 + temp);

            if(distribute_flag)
            {
            	q++;

	            /* 特殊处理 */
	            if((4 == Len && 2 == q) || (6 == Len && 0 == (q + 1) % 2))
	            {
	                X -= 1;
	            }
	        }
		}
    }
}

/************************************************
函数名称 ： OLED_Display_On
功    能 ： 开启OLED显示
参    数 ： 无
返 回 值 ： 无
*************************************************/
void OLED_Display_On(void)
{
	OLED_Write_Cmd(0x8D);       //SET DCDC命令
	OLED_Write_Cmd(0x14);       //DCDC ON
	OLED_Write_Cmd(0xAF);       //DISPLAY ON
}

/************************************************
函数名称 ： OLED_Display_Off
功    能 ： 关闭OLED显示
参    数 ： 无
返 回 值 ： 无
*************************************************/
void OLED_Display_Off(void)
{
	OLED_Write_Cmd(0x8D);       // SET DCDC命令
	OLED_Write_Cmd(0x10);       // DCDC OFF
	OLED_Write_Cmd(0xAE);       // DISPLAY OFF
}


/************************************************
函数名称 ： OLED_Init
功    能 ： OLED初始化
参    数 ： 无
返 回 值 ： 无
*************************************************/
void OLED_Init(void)
{

    /* 从上电到下面开始初始化要有足够的时间，即等待 RC复位完毕 */
    OLED_Delay_ms(100);

    OLED_Write_Cmd(0xAE);    // 关闭OLED -- turn off oled panel
    OLED_Write_Cmd(0xD5);    // 设置显示时钟分频因子/振荡器频率 -- set display clock divide ratio/oscillator frequency
    OLED_Write_Cmd(0x80);    // \ set divide ratio, Set Clock as 100 Frames/Sec
    OLED_Write_Cmd(0x20);    // 设置内存寻址模式 -- Set Memory Addressing Mode (0x00 / 0x01 / 0x02)
    OLED_Write_Cmd(0x02);    // \ Page Addressing
    OLED_Write_Cmd(0xA8);    // 设置多路传输比率 -- set multiplex ratio (16 to 63)
    OLED_Write_Cmd(0x3F);    // \ 1 / 64 duty
    OLED_Write_Cmd(0xDA);    // 设置列引脚硬件配置 -- set com pins hardware configuration
    OLED_Write_Cmd(0x12);    // \ Sequential COM pin configuration，Enable COM Left/Right remap

    /* ----- 方向显示配置 ----- */
    OLED_Write_Cmd(0xA1);    // 设置段重映射 -- Set SEG / Column Mapping     0xA0左右反置（复位值） 0xA1正常（重映射值）
    OLED_Write_Cmd(0xC8);    // 设置列输出扫描方向 -- Set COM / Row Scan Direction   0xc0上下反置（复位值） 0xC8正常（重映射值）
    /* ----- END ----- */

    OLED_Write_Cmd(0x40);    // 设置设置屏幕（GDDRAM）起始行 -- Set Display Start Line (0x40~0x7F)
    OLED_Write_Cmd(0xD3);    // 设置显示偏移 -- set display offset (0x00~0x3F)
    OLED_Write_Cmd(0x00);    // \ not offset
    OLED_Write_Cmd(0x81);    // 设置对比度 -- set contrast control register (0x00~0x100)
    OLED_Write_Cmd(0xCF);    // \ Set SEG Output Current Brightness
    OLED_Write_Cmd(0xD9);    // 设置预充电期间的持续时间 -- set pre-charge period
    OLED_Write_Cmd(0xF1);    // \ Set Pre-Charge as 15 Clocks & Discharge as 1 Clock
    OLED_Write_Cmd(0xDB);    // 调整VCOMH调节器的输出 -- set vcomh (0x00 / 0x20 / 0x30)
    OLED_Write_Cmd(0x20);    // \ Set VCOM Deselect Level
    OLED_Write_Cmd(0x8D);    // 电荷泵设置 -- set Charge Pump enable / disable (0x14 / 0x10)
    OLED_Write_Cmd(0x14);    // \ Enable charge pump during display on
    OLED_Write_Cmd(0xA4);    //  全局显示开启(黑屏/亮屏) -- Entire Display On (0xA4 / 0xA5)
    OLED_Write_Cmd(0xA6);    // 设置显示方式(正常/反显) -- set normal display (0xA6 / 0xA7)

    OLED_Write_Cmd(0xAF);    // 打开OLED -- turn on oled panel
    OLED_Fill(0x00);         // 初始清屏
    OLED_Coord(0,0);         // 设置原点坐标（0, 0）
}

/************************* 	需要提供字库相关文件 *************************/

#ifdef _FONT_LIBRARY

/************************************************
函数名称 ： OLED_ShowChinese
功    能 ： OLED单汉字显示 
参    数 ： X ---- X轴
			Y ---- Y轴
            pArray ---- 数据
            Inverse ---- 反白显示使能
返 回 值 ： 无 
*************************************************/
void OLED_ShowChinese( uint8_t X, uint8_t Y, const uint8_t *pArray, uint8_t Inverse )
{
	uint8_t i;
	uint8_t buffer[GB2312_1616_BYTE_SIZE] = {0};

    if(X <= OLED_MAX_COLUMN - 16 && (Y < (OLED_MAX_ROW >> 3)))
	{
		Get_GB2312_Code(buffer, pArray);
		
		OLED_Coord(X, Y);
		for(i = 0;i < 16;i++)
		{
			OLED_Write_Data(buffer[i], Inverse);      // 前十六个数据
		}
		OLED_Coord(X, Y+1);
		for(i = 0;i < 16;i++)
		{
			OLED_Write_Data(buffer[i + 16], Inverse); // 后十六个数据
		}
	}
}

/************************************************
函数名称 ： OLED_Draw_Font
功    能 ： OLED中英输出显示（支持混合显示）
参    数 ： X ---- X轴
			Y ---- Y轴
            pArray ---- 数据
            Inverse ---- 反白显示使能
返 回 值 ： 无 
*************************************************/
void OLED_Draw_Font( uint8_t X, uint8_t Y, const uint8_t *pArray, uint8_t Inverse )
{
	uint8_t i = 0;
	uint16_t j = 0;
	uint8_t buffer[GB2312_1616_BYTE_SIZE] = {0};
	
	while(*pArray != '\0')
	{
		if(*pArray < 127)			// ASCII码
		{
			if(X + 8 > OLED_MAX_COLUMN)
			{
				X = 0;
				Y += 2;			// 换行
			}
			if(Y > (OLED_MAX_ROW >> 3))
			{
				X = 0;
				Y = 0;			// 跳到原点
			}
			
			OLED_ShowChar(X, Y, *pArray, OLED_FONT_SIXTEEN, Inverse);
			X += 8;
			pArray++;			// 一个 ASCII码1个字节
		}
		else						// GB2312码
		{
			if(X + 16 > OLED_MAX_COLUMN)
			{
				X = 0;
				Y += 2;			// 换行
			}
			if(Y > (OLED_MAX_ROW >> 3))
			{
				X = 0;
				Y = 0;			// 跳到原点
			}

//			Get_GB2312_Code(buffer, pArray);
//			
//			OLED_Coord(X, Y);
//			for(i = 0;i < 16;i++)
//			{
//				OLED_Write_Data(*(buffer + 2*j*16 + i), Inverse);      // 前十六个数据
//			}
//			OLED_Coord(X, Y+1);
//			for(i = 0;i < 16;i++)
//			{
//				OLED_Write_Data(*(buffer + 2*j*16 + 16 + i), Inverse); // 后十六个数据
//			}
//			j++;
			
			OLED_ShowChinese(X, Y, pArray, Inverse);
			X += 16;
			pArray += 2;		// 一个 GB2312文字两个字节
		}
	}
}

#endif /* _FONT_LIBRARY */


/************************* 	需要提供字库相关文件 *************************/


/*---------------------------- END OF FILE ----------------------------*/