激光追踪云台
#include "stm32f10x.h"
#include "Delay.h"
#include "LED.h"
#include "Key.h"
#include "OLED.h"
#include "PWM.h"
#include "Servo.h"
#include <math.h>

/*====================================================
 * STM32F103C8T6 双 MG995 激光追踪云台主程序
 *
 * 按键:
 *   PB1  -> Key_GetNum() 返回 1:设置圈数,1~5循环
 *   PB11 -> Key_GetNum() 返回 2:启动轨迹
 *
 * 舵机:
 *   Servo_SetAngle2() -> TIM2_CH2 -> PA1:水平舵机
 *   Servo_SetAngle3() -> TIM2_CH3 -> PA2:竖直舵机
 *
 * 注意:Servo_Init() 内部已调用 PWM_Init(),因此这里不重复初始化。
 *====================================================*/

/* 屏幕与云台参数,单位:mm */
#define SCREEN_DISTANCE_MM     1500.0f

/*
 * 屏幕外沿 300 mm x 210 mm,胶带宽度约 18 mm。
 * 以下按胶带中心线规划轨迹:
 * X 半宽 = (300 - 18) / 2 = 141 mm
 * Y 半高 = (210 - 18) / 2 = 96 mm
 * 如需按屏幕外沿运行,改为 150 mm 和 105 mm。
 */
#define HALF_WIDTH_MM          141.0f
#define HALF_HEIGHT_MM          96.0f

#define RAD_TO_DEG              57.2957795f

/* 舵机角度校准:中心位置为 90 度 */
#define SERVO_H_CENTER_DEG      90.0f
#define SERVO_V_CENTER_DEG      101.8f

/*
 * 方向修正:如果水平向右实际向左,将 H_DIR 改为 -1;
 * 如果屏幕向上实际向下,将 V_DIR 改为 -1。
 */
#define H_DIR                   1.0f
#define V_DIR                   1.0f

/* MG995 角度限幅,避免初次调试时冲击机械限位 */
#define SERVO_MIN_DEG           45.0f
#define SERVO_MAX_DEG           135.0f

/* 轨迹插值参数 */
#define MOVE_STEP_MM            30.0f
#define MOVE_DELAY_MS           40
#define CORNER_DELAY_MS         120

/* ===== 经验校准参数:补偿舵机非线性与机械安装误差 ===== */
#define H_GAIN          1.02f    /* 水平幅度增益:左/右不够宽时增大 */
#define V_GAIN          1.07f    /* 竖直幅度增益:上/下不够高时增大 */
#define H_OFFSET_DEG    0.0f    /* 水平整体偏移:整体偏右→负;偏左→正(H_DIR=1时) */
#define V_OFFSET_DEG    0.0f    /* 竖直整体偏移:整体偏下→正;偏上→负(V_DIR=1时) */

/* 轨迹整体水平偏移,补偿齿隙/光轴偏心;负值=左移,单位 mm */
#define TRACK_X_SHIFT_MM    (+16.0f)
#define TX(x)   ((x) + TRACK_X_SHIFT_MM)
/* 当前光斑在屏幕坐标系中的位置,原点为屏幕中心 */
/* 轨迹整体竖直偏移,补偿齿隙/光轴偏心;负值=下移,正值=上移,单位 mm */
#define TRACK_Y_SHIFT_MM    (-5.0f)     /* 先按实测偏上量填,负号=下移 */
#define TY(y)   ((y) + TRACK_Y_SHIFT_MM)
static float CurrentX = 0.0f;
static float CurrentY = 0.0f;

/* 当前设置的圈数 */
static uint8_t LoopCount = 1;


/* 将舵机角度限制在安全范围内 */
static float LimitServoAngle(float Angle)
{
    if (Angle < SERVO_MIN_DEG)
    {
        Angle = SERVO_MIN_DEG;
    }
    else if (Angle > SERVO_MAX_DEG)
    {
        Angle = SERVO_MAX_DEG;
    }

    return Angle;
}


/*
 * 根据屏幕坐标 (x, y) 计算两个舵机角度。
 * x 正方向:屏幕向右;y 正方向:屏幕向上。
 */
static void Gimbal_SetTarget(float x, float y)
{
    float PanAngle;
    float TiltAngle;
    float HorizontalDistance;
    float HorizontalServoAngle;
    float VerticalServoAngle;

    PanAngle = atan2f(x, SCREEN_DISTANCE_MM) * RAD_TO_DEG;

    HorizontalDistance = sqrtf(SCREEN_DISTANCE_MM * SCREEN_DISTANCE_MM + x * x);
    TiltAngle = atan2f(y, HorizontalDistance) * RAD_TO_DEG;

	HorizontalServoAngle = SERVO_H_CENTER_DEG + H_OFFSET_DEG + H_DIR * H_GAIN * PanAngle;
	VerticalServoAngle   = SERVO_V_CENTER_DEG + V_OFFSET_DEG + V_DIR * V_GAIN * TiltAngle;

    HorizontalServoAngle = LimitServoAngle(HorizontalServoAngle);
    VerticalServoAngle = LimitServoAngle(VerticalServoAngle);

    Servo_SetAngle2(HorizontalServoAngle);
    Servo_SetAngle3(VerticalServoAngle);
}


/* 从当前位置沿直线移动到目标坐标 */
static void Gimbal_MoveTo(float TargetX, float TargetY)
{
    float StartX;
    float StartY;
    float DeltaX;
    float DeltaY;
    float MaxDelta;
    float t;
    float x;
    float y;
    int Steps;
    int i;

    StartX = CurrentX;
    StartY = CurrentY;

    DeltaX = TargetX - StartX;
    DeltaY = TargetY - StartY;

    if (fabsf(DeltaX) > fabsf(DeltaY))
    {
        MaxDelta = fabsf(DeltaX);
    }
    else
    {
        MaxDelta = fabsf(DeltaY);
    }

    Steps = (int)(MaxDelta / MOVE_STEP_MM);
    if ((float)Steps * MOVE_STEP_MM < MaxDelta)
    {
        Steps++;
    }
    if (Steps < 1)
    {
        Steps = 1;
    }

    for (i = 1; i <= Steps; i++)
    {
        t = (float)i / (float)Steps;
        x = StartX + DeltaX * t;
        y = StartY + DeltaY * t;

        Gimbal_SetTarget(x, y);
        Delay_ms(MOVE_DELAY_MS);
    }

    CurrentX = TargetX;
    CurrentY = TargetY;
}


/* OLED 显示待机界面 */
static void OLED_ShowReady(void)
{
    OLED_Clear();
    OLED_ShowString(1, 1, "Laser Gimbal");
    OLED_ShowString(2, 1, "Loops: ");
    OLED_ShowNum(2, 8, LoopCount, 1);
    OLED_ShowString(3, 1, "K1: Set loops");
    OLED_ShowString(4, 1, "K2: Start");
}


/* 执行 N 圈矩形轨迹 */
static void Gimbal_RunTrajectory(uint8_t N)
{
    uint8_t i;

    if ((N < 1) || (N > 5))
    {
        return;
    }

    OLED_Clear();
    OLED_ShowString(1, 1, "Trajectory Run");
    OLED_ShowString(2, 1, "Total: ");
    OLED_ShowNum(2, 8, N, 1);

    LED1_ON();                 /* LED1 作为运行状态指示灯 */

    /* 回到中心原点,再开始轨迹 */
    CurrentX = 0.0f;
    CurrentY = 0.0f;
    Gimbal_SetTarget(0.0f, 0.0f);
    Delay_ms(500);

     /* 原点 -> 右侧边线中点 */
    Gimbal_MoveTo(TX(HALF_WIDTH_MM), 0.0f);

    /* 从右侧中点开始,依次沿上、左、下边线逆时针运行 */
    for (i = 0; i < N; i++)
    {
        OLED_ShowString(3, 1, "Loop: ");
        OLED_ShowNum(3, 7, (uint32_t)(i + 1), 1);
        OLED_ShowString(3, 8, "/");
        OLED_ShowNum(3, 9, N, 1);

        /* 右侧中点 -> 右上角 */
        Gimbal_MoveTo(TX( HALF_WIDTH_MM), TY( HALF_HEIGHT_MM));
        Delay_ms(CORNER_DELAY_MS);

        /* 右上角 -> 左上角 */
		Gimbal_MoveTo(TX(-HALF_WIDTH_MM), TY( HALF_HEIGHT_MM));
        Delay_ms(CORNER_DELAY_MS);


        /* 左上角 -> 左下角 */
        Gimbal_MoveTo(TX(-HALF_WIDTH_MM), TY(-HALF_HEIGHT_MM));
        Delay_ms(CORNER_DELAY_MS);

        /* 左下角 -> 右下角 */
        Gimbal_MoveTo(TX( HALF_WIDTH_MM), TY(-HALF_HEIGHT_MM));
        Delay_ms(CORNER_DELAY_MS);

        /* 右下角 -> 右侧边线中点,完成一圈 */
        Gimbal_MoveTo(TX( HALF_WIDTH_MM),  0.0f);
        Delay_ms(CORNER_DELAY_MS);
	}

    /* 完成 N 圈后,右侧中点 -> 原点 */
    Gimbal_MoveTo(0.0f, 0.0f);
    Delay_ms(300);

    LED1_OFF();

    OLED_Clear();
    OLED_ShowString(1, 1, "Trajectory Done");
    OLED_ShowString(2, 1, "Returned Origin");
    OLED_ShowString(4, 1, "K1:Set K2:Start");
}


int main(void)
{
    uint8_t KeyNum;
//	int i;

    /* 初始化各模块 */
    LED_Init();
    Key_Init();
    OLED_Init();
    Servo_Init();            /* Servo_Init 内部调用 PWM_Init */

    /* 两个舵机回到中心位置 */
    Servo_SetAngle2(SERVO_H_CENTER_DEG);
    Servo_SetAngle3(SERVO_V_CENTER_DEG);
    Delay_ms(500);

    LED1_OFF();
    LED2_OFF();

    OLED_ShowReady();
///* ===== 临时校准:扫描垂直舵机,找打在屏幕中心的角度 ===== */
//	
//	OLED_Clear();
//	OLED_ShowString(1, 1, "V Calibrate");
//	for (i = 80; i <= 120; i += 5)
//	{
//    Servo_SetAngle3((float)i);
//    OLED_ShowString(3, 1, "Angle: ");
//    OLED_ShowNum(3, 8, (uint32_t)i, 3);
//    Delay_ms(2000);     /* 每个角度停 2 秒,用眼睛看光斑位置 */
//	}
///* 记下光斑落在屏幕中心时的角度,写回 SERVO_V_CENTER_DEG */
    while (1)
    {
        KeyNum = Key_GetNum();


        if (KeyNum == 1)
        {
            /* PB1:圈数 1 -> 2 -> 3 -> 4 -> 5 -> 1 */
            LoopCount++;
            if (LoopCount > 5)
            {
                LoopCount = 1;
            }

            OLED_ShowReady();
        }
        else if (KeyNum == 2)
        {
            /* PB11:启动当前设置圈数的轨迹 */
            Gimbal_RunTrajectory(LoopCount);
        }

        Delay_ms(10);
    }
}

#include "stm32f10x.h"
#include "Delay.h"

void Key_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;  // 上拉输入
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
}

uint8_t Key_GetNum(void)
{
	uint8_t KeyNum = 0;
	// 静态变量,只初始化一次,保持记忆
	static uint8_t key1_lock = 0; 
	static uint8_t key2_lock = 0; 
	
	// ---------------- 检测按键1 (PB1) ----------------
	if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1) == 0 && key1_lock == 0)
	{
		Delay_ms(20); // 消抖
		if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1) == 0) // 再次确认
		{
			KeyNum = 1;
			key1_lock = 1; // 锁定,直到松手
		}
	}
	else if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1) == 1) // 松手检测
	{
		key1_lock = 0; // 松手解锁
	}
	
	// ---------------- 检测按键2 (PB11) ----------------
	if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_11) == 0 && key2_lock == 0)
	{
		Delay_ms(20); // 消抖
		if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_11) == 0)
		{
			KeyNum = 2;
			key2_lock = 1; // 锁定
		}
	}
	else if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_11) == 1)
	{
		key2_lock = 0; // 松手解锁
	}
	
	return KeyNum;
}

#include "stm32f10x.h"

void PWM_Init(void)
{
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;  // PA1, PA2
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	TIM_InternalClockConfig(TIM2);
	
	TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
	TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
	TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
	TIM_TimeBaseInitStructure.TIM_Period = 20000 - 1;		// 50Hz
	TIM_TimeBaseInitStructure.TIM_Prescaler = 72 - 1;		// 1MHz 计数
	TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;
	TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStructure);
	
	TIM_OCInitTypeDef TIM_OCInitStructure;
	
	// 配置通道2 (PA1)
	TIM_OCStructInit(&TIM_OCInitStructure);
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
	TIM_OCInitStructure.TIM_Pulse = 1500; // 默认给 1.5ms (中位)
	TIM_OC2Init(TIM2, &TIM_OCInitStructure);
    TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Enable); // 新增:开启预装载
	
	// 配置通道3 (PA2)
	TIM_OCStructInit(&TIM_OCInitStructure);
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
	TIM_OCInitStructure.TIM_Pulse = 1500; // 默认给 1.5ms (中位)
	TIM_OC3Init(TIM2, &TIM_OCInitStructure);
    TIM_OC3PreloadConfig(TIM2, TIM_OCPreload_Enable); // 新增:开启预装载
	
	TIM_Cmd(TIM2, ENABLE);
}

void PWM_SetCompare2(uint16_t Compare)
{
	TIM_SetCompare2(TIM2, Compare);
}

void PWM_SetCompare3(uint16_t Compare)
{
	TIM_SetCompare3(TIM2, Compare);
}
 
#include "stm32f10x.h"                  // Device header
#include "PWM.h"

void Servo_Init(void)
{
	PWM_Init();
}


void Servo_SetAngle2(float Angle)
{
	PWM_SetCompare2((uint16_t)(Angle / 180.0f * 2000.0f + 500.0f));
}

void Servo_SetAngle3(float Angle)
{
	PWM_SetCompare3((uint16_t)(Angle / 180.0f * 2000.0f + 500.0f));
}

#include "stm32f10x.h"                  // Device header

void LED_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	GPIO_SetBits(GPIOA, GPIO_Pin_1 | GPIO_Pin_2);
}

void LED1_ON(void)
{
	GPIO_ResetBits(GPIOA, GPIO_Pin_1);
}

void LED1_OFF(void)
{
	GPIO_SetBits(GPIOA, GPIO_Pin_1);
}

void LED1_Turn(void)
{
	if (GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_1) == 0)
	{
		GPIO_SetBits(GPIOA, GPIO_Pin_1);
	}
	else
	{
		GPIO_ResetBits(GPIOA, GPIO_Pin_1);
	}
}
void LED2_ON(void)
{
	GPIO_ResetBits(GPIOA, GPIO_Pin_2);
}

void LED2_OFF(void)
{
	GPIO_SetBits(GPIOA, GPIO_Pin_2);
}

void LED2_Turn(void)
{
	if (GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_2) == 0)
	{
		GPIO_SetBits(GPIOA, GPIO_Pin_2);
	}
	else
	{
		GPIO_ResetBits(GPIOA, GPIO_Pin_2);
	}
}

#include "stm32f10x.h"
#include "OLED_Font.h"

/*引脚配置*/
#define OLED_W_SCL(x)		GPIO_WriteBit(GPIOB, GPIO_Pin_8, (BitAction)(x))
#define OLED_W_SDA(x)		GPIO_WriteBit(GPIOB, GPIO_Pin_9, (BitAction)(x))

/*引脚初始化*/
void OLED_I2C_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
 	GPIO_Init(GPIOB, &GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
 	GPIO_Init(GPIOB, &GPIO_InitStructure);
	
	OLED_W_SCL(1);
	OLED_W_SDA(1);
}

/**
  * @brief  I2C开始
  * @param  无
  * @retval 无
  */
void OLED_I2C_Start(void)
{
	OLED_W_SDA(1);
	OLED_W_SCL(1);
	OLED_W_SDA(0);
	OLED_W_SCL(0);
}

/**
  * @brief  I2C停止
  * @param  无
  * @retval 无
  */
void OLED_I2C_Stop(void)
{
	OLED_W_SDA(0);
	OLED_W_SCL(1);
	OLED_W_SDA(1);
}

/**
  * @brief  I2C发送一个字节
  * @param  Byte 要发送的一个字节
  * @retval 无
  */
void OLED_I2C_SendByte(uint8_t Byte)
{
	uint8_t i;
	for (i = 0; i < 8; i++)
	{
		OLED_W_SDA(Byte & (0x80 >> i));
		OLED_W_SCL(1);
		OLED_W_SCL(0);
	}
	OLED_W_SCL(1);	//额外的一个时钟,不处理应答信号
	OLED_W_SCL(0);
}

/**
  * @brief  OLED写命令
  * @param  Command 要写入的命令
  * @retval 无
  */
void OLED_WriteCommand(uint8_t Command)
{
	OLED_I2C_Start();
	OLED_I2C_SendByte(0x78);		//从机地址
	OLED_I2C_SendByte(0x00);		//写命令
	OLED_I2C_SendByte(Command); 
	OLED_I2C_Stop();
}

/**
  * @brief  OLED写数据
  * @param  Data 要写入的数据
  * @retval 无
  */
void OLED_WriteData(uint8_t Data)
{
	OLED_I2C_Start();
	OLED_I2C_SendByte(0x78);		//从机地址
	OLED_I2C_SendByte(0x40);		//写数据
	OLED_I2C_SendByte(Data);
	OLED_I2C_Stop();
}

/**
  * @brief  OLED设置光标位置
  * @param  Y 以左上角为原点,向下方向的坐标,范围:0~7
  * @param  X 以左上角为原点,向右方向的坐标,范围:0~127
  * @retval 无
  */
void OLED_SetCursor(uint8_t Y, uint8_t X)
{
	OLED_WriteCommand(0xB0 | Y);					//设置Y位置
	OLED_WriteCommand(0x10 | ((X & 0xF0) >> 4));	//设置X位置高4位
	OLED_WriteCommand(0x00 | (X & 0x0F));			//设置X位置低4位
}

/**
  * @brief  OLED清屏
  * @param  无
  * @retval 无
  */
void OLED_Clear(void)
{  
	uint8_t i, j;
	for (j = 0; j < 8; j++)
	{
		OLED_SetCursor(j, 0);
		for(i = 0; i < 128; i++)
		{
			OLED_WriteData(0x00);
		}
	}
}

/**
  * @brief  OLED显示一个字符
  * @param  Line 行位置,范围:1~4
  * @param  Column 列位置,范围:1~16
  * @param  Char 要显示的一个字符,范围:ASCII可见字符
  * @retval 无
  */
void OLED_ShowChar(uint8_t Line, uint8_t Column, char Char)
{      	
	uint8_t i;
	OLED_SetCursor((Line - 1) * 2, (Column - 1) * 8);		//设置光标位置在上半部分
	for (i = 0; i < 8; i++)
	{
		OLED_WriteData(OLED_F8x16[Char - ' '][i]);			//显示上半部分内容
	}
	OLED_SetCursor((Line - 1) * 2 + 1, (Column - 1) * 8);	//设置光标位置在下半部分
	for (i = 0; i < 8; i++)
	{
		OLED_WriteData(OLED_F8x16[Char - ' '][i + 8]);		//显示下半部分内容
	}
}

/**
  * @brief  OLED显示字符串
  * @param  Line 起始行位置,范围:1~4
  * @param  Column 起始列位置,范围:1~16
  * @param  String 要显示的字符串,范围:ASCII可见字符
  * @retval 无
  */
void OLED_ShowString(uint8_t Line, uint8_t Column, char *String)
{
	uint8_t i;
	for (i = 0; String[i] != '\0'; i++)
	{
		OLED_ShowChar(Line, Column + i, String[i]);
	}
}

/**
  * @brief  OLED次方函数
  * @retval 返回值等于X的Y次方
  */
uint32_t OLED_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y--)
	{
		Result *= X;
	}
	return Result;
}

/**
  * @brief  OLED显示数字(十进制,正数)
  * @param  Line 起始行位置,范围:1~4
  * @param  Column 起始列位置,范围:1~16
  * @param  Number 要显示的数字,范围:0~4294967295
  * @param  Length 要显示数字的长度,范围:1~10
  * @retval 无
  */
void OLED_ShowNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i++)							
	{
		OLED_ShowChar(Line, Column + i, Number / OLED_Pow(10, Length - i - 1) % 10 + '0');
	}
}

/**
  * @brief  OLED显示数字(十进制,带符号数)
  * @param  Line 起始行位置,范围:1~4
  * @param  Column 起始列位置,范围:1~16
  * @param  Number 要显示的数字,范围:-2147483648~2147483647
  * @param  Length 要显示数字的长度,范围:1~10
  * @retval 无
  */
void OLED_ShowSignedNum(uint8_t Line, uint8_t Column, int32_t Number, uint8_t Length)
{
	uint8_t i;
	uint32_t Number1;
	if (Number >= 0)
	{
		OLED_ShowChar(Line, Column, '+');
		Number1 = Number;
	}
	else
	{
		OLED_ShowChar(Line, Column, '-');
		Number1 = -Number;
	}
	for (i = 0; i < Length; i++)							
	{
		OLED_ShowChar(Line, Column + i + 1, Number1 / OLED_Pow(10, Length - i - 1) % 10 + '0');
	}
}

/**
  * @brief  OLED显示数字(十六进制,正数)
  * @param  Line 起始行位置,范围:1~4
  * @param  Column 起始列位置,范围:1~16
  * @param  Number 要显示的数字,范围:0~0xFFFFFFFF
  * @param  Length 要显示数字的长度,范围:1~8
  * @retval 无
  */
void OLED_ShowHexNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
	uint8_t i, SingleNumber;
	for (i = 0; i < Length; i++)							
	{
		SingleNumber = Number / OLED_Pow(16, Length - i - 1) % 16;
		if (SingleNumber < 10)
		{
			OLED_ShowChar(Line, Column + i, SingleNumber + '0');
		}
		else
		{
			OLED_ShowChar(Line, Column + i, SingleNumber - 10 + 'A');
		}
	}
}

/**
  * @brief  OLED显示数字(二进制,正数)
  * @param  Line 起始行位置,范围:1~4
  * @param  Column 起始列位置,范围:1~16
  * @param  Number 要显示的数字,范围:0~1111 1111 1111 1111
  * @param  Length 要显示数字的长度,范围:1~16
  * @retval 无
  */
void OLED_ShowBinNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i++)							
	{
		OLED_ShowChar(Line, Column + i, Number / OLED_Pow(2, Length - i - 1) % 2 + '0');
	}
}

/**
  * @brief  OLED初始化
  * @param  无
  * @retval 无
  */
void OLED_Init(void)
{
	uint32_t i, j;
	
	for (i = 0; i < 1000; i++)			//上电延时
	{
		for (j = 0; j < 1000; j++);
	}
	
	OLED_I2C_Init();			//端口初始化
	
	OLED_WriteCommand(0xAE);	//关闭显示
	
	OLED_WriteCommand(0xD5);	//设置显示时钟分频比/振荡器频率
	OLED_WriteCommand(0x80);
	
	OLED_WriteCommand(0xA8);	//设置多路复用率
	OLED_WriteCommand(0x3F);
	
	OLED_WriteCommand(0xD3);	//设置显示偏移
	OLED_WriteCommand(0x00);
	
	OLED_WriteCommand(0x40);	//设置显示开始行
	
	OLED_WriteCommand(0xA1);	//设置左右方向,0xA1正常 0xA0左右反置
	
	OLED_WriteCommand(0xC8);	//设置上下方向,0xC8正常 0xC0上下反置

	OLED_WriteCommand(0xDA);	//设置COM引脚硬件配置
	OLED_WriteCommand(0x12);
	
	OLED_WriteCommand(0x81);	//设置对比度控制
	OLED_WriteCommand(0xCF);

	OLED_WriteCommand(0xD9);	//设置预充电周期
	OLED_WriteCommand(0xF1);

	OLED_WriteCommand(0xDB);	//设置VCOMH取消选择级别
	OLED_WriteCommand(0x30);

	OLED_WriteCommand(0xA4);	//设置整个显示打开/关闭

	OLED_WriteCommand(0xA6);	//设置正常/倒转显示

	OLED_WriteCommand(0x8D);	//设置充电泵
	OLED_WriteCommand(0x14);

	OLED_WriteCommand(0xAF);	//开启显示
		
	OLED_Clear();				//OLED清屏
}