PWM测试编码器速度

2万 · 2018-3-7 14:17

//
#include "Driver\DrvGPIO.h"
#include "Driver\DrvSYS.h"
#include "Driver\DrvPWM.h"
#include "Driver\DrvTimer.h"
//
#include "nuc_pwm.h"
//
#include "MYFUN\BIANMAQI.H"
#include "MYFUN\DISPLAY.H"
#include "MYFUN\TIMINIT.H"
#include "MYFUN\BIANLIANGBIAO.H"

//
int main(void)
{
SYSinit();
//PWM捕获初始化
PWMinit();
SETPWMCAP();
FIRSTCLRCAPIRQ();
InitLCD();
TimerInit();
while (1)
{

g_lSpeed = PWM_cnt[6] - g_wCount;
g_wCount = PWM_cnt[6];
SUDU = g_lSpeed*10 / 1024;

DispString(0, 0, "计数：");
DispFloat(0, 3, PWM_cnt[6], 0);

DispString(1, 0, "计时：");
DispFloat(1, 3, CT, 0);

DispString(2, 0, "脉冲：");
DispFloat(2, 3, fabs(g_lSpeed), 0);

DispString(3, 0, "转秒：");
DispFloat(3, 3, fabs(SUDU), 0);

}
}

主程序如上所示

2万 · 2018-3-7 14:19

#ifndef _BIANLIANGBIAO_H_
#define _BIANLIANGBIAO_H_
uint8_t CT=0;
//设定了使用次数
uint16_t SETBUG,LCDCLRFLAG,BUGNUMBER,BUGNUMBER_M;
//地址偏移
uint16_t i;
#define VD(n) 0x00000004*n
//圆周率
#define Pi 3.14
//脉冲当量
#define PWMDangLiang
//键盘数组
const uint32_t KEY[] =
{
      0,
      1,
      2,
      3,
      4,
      5,
      6,
      7,
      8,
      12,
      21,
      19,
      9,
      10,
      22,
      20,
      11,
      17,
      18,
      16,
      14,
      13,
      23,
      24,
      15,
      25,
      26
};
uint8_t KEYSCAN;
uint32_t KEYNUM[2] =
{
0, 0
};
uint8_t num[] =
{
0, 0, 0, 0, 0, 0
};
uint8_t cnt = 0, floatflag = 0, flocnt = 0;
float NUM0 = 0;
float NUM1 = 0;
uint8_t INTPUTFLAG = 0;
//PWM变量
//PWM计数
int32_t PWM_cnt[9];//记录自动状态
int32_t PWM_cnt_Q[9];//记录清零脉冲数
int32_t PWM_cnt_M[9];//记录原位的脉冲数
//PWM上升沿中断函数
uint8_t PWM_RISING[9];
//PWM下降沿中断函数
uint8_t PWM_FALLING[9];

uint32_t g_wCount=0;
int32_t  g_lSpeed=0;
int32_t SUDU=0;

//状态机
//……指针……菜单层数……层数指示
uint8_t OP = 0, Step, Ste;
//显示游标
#define OPDisp  OP%4
//公共显示内容
const uint8_t sESC[] = "【返回】";
const uint8_t sDN[] = "【下页】";
const uint8_t sUP[] = "【上页】";
const uint8_t sTAB[] = "    ";
const uint8_t ERROR[] = "可能部件损坏！";
//初始画面内容
const uint8_t s00[] = "①〖参数设置〗";
const uint8_t s01[] = "②〖周向控制〗";
const uint8_t s02[] = "③〖轴向控制〗";
const uint8_t s03[] = "④〖工作状态〗";
//参数设置内容
const uint8_t s10[] = "版辊直径";
const uint8_t s11[] = "编码器线数";
const uint8_t s12[] = "轴向限制";
const uint8_t s13[] = "轴向节距";
//偏移地址：VD(0)直径
float ZGZJ;
float ZGZJ_M;
//偏移地址：VD(1)编码器线数
uint16_t BMQXS;
uint16_t BMQXS_M;
//偏移地址：VD(2)轴向保护距离
float ZXBHJL;
float ZXBHJL_M;
//偏移地址：VD(3)节距
float JJ;
float JJ_M;
/*-------------------------------------------------------------*/
const uint8_t s20[] = "周向正";
const uint8_t s21[] = "周向反";
const uint8_t s22[] = "行走";
const uint8_t s23[] = "周向◎";
const uint8_t s24[] = "周向≯";
const uint8_t s25[] = "周向≮";
const uint8_t s26[] = "周向热故障";
const uint8_t s27[] = "寻找周向原点";
const uint8_t s28[] = "位置";
const uint8_t s29[] = "〖周向归零〗";
uint8_t XWFLAGERROR = 0;//相位错误标志
uint8_t XWFLAG = 0;
uint8_t XWZHUANXIANG = 0;
//偏移地址：VD(4)
float XWZX;
float XWZX_M;
//偏移地址：VD(5)
float XWFX;
float XWFX_M;
//偏移地址：VD(6)
float XWSY;
float XWSY_M;
//自动状态行走距离
#define XWJL Pi*ZGZJ*PWM_cnt[6]/BMQXS
//用于计算清零的数据
#define XWJLQL Pi*ZGZJ*PWM_cnt_Q[6]/BMQXS
//手动状态行走距离
#define XWJLM Pi*ZGZJ*PWM_cnt_M[6]/BMQXS
////输入距离换算成脉冲数
//#define XWZXMC (uint32_t)(round((XWZX*BMQXS*1000)/(Pi*ZGZJ*1000)))
//#define XWFXMC (uint32_t)(round((XWFX*BMQXS*1000)/(Pi*ZGZJ*1000)))
/*-------------------------------------------------------------*/
const uint8_t s30[] = "轴向正";
const uint8_t s31[] = "轴向反";
const uint8_t s32[] = "行走";
const uint8_t s33[] = "轴向●";
const uint8_t s34[] = "轴向≯";
const uint8_t s35[] = "轴向≮";
const uint8_t s36[] = "轴向热故障";
const uint8_t s37[] = "寻找轴向原点";
const uint8_t s38[] = "位置";
const uint8_t s39[] = "〖轴向归零〗";
uint8_t ZXFLAGERROR = 0;//相位错误标志
uint8_t ZXFLAG = 0;
uint8_t ZXZHUANXIANG = 0;
uint8_t XIANWEIFLAG = 0;//轴向寻找原点的状态机
//偏移地址：VD(7)
float ZXZX;
float ZXZX_M;
//偏移地址：VD(8)
float ZXFX;
float ZXFX_M;
//偏移地址：VD(9)
float ZXSY;
float ZXSY_M;
//自动状态行走距离
#define ZXJL JJ*PWM_cnt[5]/BMQXS
//用于计算清零的数据
#define ZXJLQL JJ*PWM_cnt_Q[5]/BMQXS
//手动状态行走距离
#define ZXJLM JJ*PWM_cnt_M[5]/BMQXS
////输入距离换算成脉冲数
//#define ZXZXMC (uint32_t)(round(((ZXZX*BMQXS*1000)/(JJ*1000))))
//#define ZXFXMC (uint32_t)(round(((ZXFX*BMQXS*1000)/(JJ*1000))))
/*-------------------------------------------------------------*/
const uint8_t s40[] = "【自动控制】";
const uint8_t s41[] = "【手动控制】";
const uint8_t s42[] = "【自动控制】";
const uint8_t s43[] = "【手动控制】";
uint8_t MAN = 0, AUTO = 0;
/*-------------------------------------------------------------*/
#endif

2万 · 2018-3-7 14:19

几层工作的状态

菜单显示

2万 · 2018-3-7 14:20

#ifndef _BIANMAQI_H_
#define _BIANMAQI_H_

#include "MYFUN\TIMINIT.H"
#include "MYFUN\BIANLIANGBIAO.H"
//声明PWM捕获终端函数
void DRVPWM_CapIRQHandler1();
void DRVPWM_CapIRQHandler2();
void DRVPWM_CapIRQHandler3();
void DRVPWM_CapIRQHandler4();
void DRVPWM_CapIRQHandler5();
void DRVPWM_CapIRQHandler6();
void DRVPWM_CapIRQHandler7();
void DRVPWM_CapIRQHandler8();
//
void PWMinit()
{
//PWM使能
DrvPWM_Open();
//PWM配置
DrvGPIO_InitFunction(FUNC_PWM01);
DrvGPIO_InitFunction(FUNC_PWM23);
DrvGPIO_InitFunction(FUNC_PWM45);
DrvGPIO_InitFunction(FUNC_PWM67);
//PWM捕获方式
DrvPWM_Enable(DRVPWM_CAP0, 1);
DrvPWM_Enable(DRVPWM_CAP1, 1);
DrvPWM_Enable(DRVPWM_CAP1, 1);
DrvPWM_Enable(DRVPWM_CAP2, 1);
DrvPWM_Enable(DRVPWM_CAP3, 1);
DrvPWM_Enable(DRVPWM_CAP4, 1);
DrvPWM_Enable(DRVPWM_CAP5, 1);
DrvPWM_Enable(DRVPWM_CAP6, 1);
DrvPWM_Enable(DRVPWM_CAP7, 1);
}
//PWM捕获函数
void SETPWMCAP()
{
DrvPWM_SetTimerIO(DRVPWM_CAP0, 1);
DrvPWM_SetTimerIO(DRVPWM_CAP1, 1);
DrvPWM_SetTimerIO(DRVPWM_CAP2, 1);
DrvPWM_SetTimerIO(DRVPWM_CAP3, 1);
DrvPWM_SetTimerIO(DRVPWM_CAP4, 1);
DrvPWM_SetTimerIO(DRVPWM_CAP5, 1);
DrvPWM_SetTimerIO(DRVPWM_CAP6, 1);
DrvPWM_SetTimerIO(DRVPWM_CAP7, 1);
//
DrvPWM_SelectClockSource(DRVPWM_CAP0, DRVPWM_HCLK);
DrvPWM_SelectClockSource(DRVPWM_CAP1, DRVPWM_HCLK);
DrvPWM_SelectClockSource(DRVPWM_CAP2, DRVPWM_HCLK);
DrvPWM_SelectClockSource(DRVPWM_CAP3, DRVPWM_HCLK);
DrvPWM_SelectClockSource(DRVPWM_CAP4, DRVPWM_HCLK);
DrvPWM_SelectClockSource(DRVPWM_CAP5, DRVPWM_HCLK);
DrvPWM_SelectClockSource(DRVPWM_CAP6, DRVPWM_HCLK);
DrvPWM_SelectClockSource(DRVPWM_CAP7, DRVPWM_HCLK);
DrvPWM_EnableInt(DRVPWM_CAP0, DRVPWM_CAP_RISING_FLAG,
      *DRVPWM_CapIRQHandler1);
DrvPWM_EnableInt(DRVPWM_CAP1, DRVPWM_CAP_RISING_FLAG,
      *DRVPWM_CapIRQHandler2);
DrvPWM_EnableInt(DRVPWM_CAP2, DRVPWM_CAP_RISING_FLAG,
      *DRVPWM_CapIRQHandler3);
DrvPWM_EnableInt(DRVPWM_CAP3, DRVPWM_CAP_RISING_FLAG,
      *DRVPWM_CapIRQHandler4);
DrvPWM_EnableInt(DRVPWM_CAP4, DRVPWM_CAP_RISING_FLAG,
      *DRVPWM_CapIRQHandler5);
DrvPWM_EnableInt(DRVPWM_CAP5, DRVPWM_CAP_RISING_FLAG,
      *DRVPWM_CapIRQHandler6);
DrvPWM_EnableInt(DRVPWM_CAP6, DRVPWM_CAP_RISING_FLAG,
      *DRVPWM_CapIRQHandler7);
DrvPWM_EnableInt(DRVPWM_CAP7, DRVPWM_CAP_RISING_FLAG,
      *DRVPWM_CapIRQHandler8);
}
//PWM终端函数
void GETPWMIRQ()
{
PWM_RISING[1] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP0,
      DRVPWM_CAP_RISING_FLAG);
PWM_FALLING[1] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP0,
      DRVPWM_CAP_FALLING_FLAG);
//
PWM_RISING[2] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP1,
      DRVPWM_CAP_RISING_FLAG);
PWM_FALLING[2] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP1,
      DRVPWM_CAP_FALLING_FLAG);
//
PWM_RISING[3] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP2,
      DRVPWM_CAP_RISING_FLAG);
PWM_FALLING[3] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP2,
      DRVPWM_CAP_FALLING_FLAG);
//
PWM_RISING[4] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP3,
      DRVPWM_CAP_RISING_FLAG);
PWM_FALLING[4] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP3,
      DRVPWM_CAP_FALLING_FLAG);
//
PWM_RISING[5] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP4,
      DRVPWM_CAP_RISING_FLAG);
PWM_FALLING[5] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP4,
      DRVPWM_CAP_FALLING_FLAG);
//
PWM_RISING[6] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP5,
      DRVPWM_CAP_RISING_FLAG);
PWM_FALLING[6] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP5,
      DRVPWM_CAP_FALLING_FLAG);
//
PWM_RISING[7] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP6,
      DRVPWM_CAP_RISING_FLAG);
PWM_FALLING[7] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP6,
      DRVPWM_CAP_FALLING_FLAG);
//
PWM_RISING[8] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP7,
      DRVPWM_CAP_RISING_FLAG);
PWM_FALLING[8] = DrvPWM_GetCaptureIntStatus(DRVPWM_CAP7,
      DRVPWM_CAP_FALLING_FLAG);
}
//清除捕获中断
void CLRCAPIRQ()
{
// 1
if (PWM_RISING[1])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP0, DRVPWM_CAP_RISING_FLAG);
}
if (PWM_FALLING[1])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP0, DRVPWM_CAP_FALLING_FLAG);
}
// 2
if (PWM_RISING[2])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP1, DRVPWM_CAP_RISING_FLAG);
}
if (PWM_FALLING[2])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP1, DRVPWM_CAP_FALLING_FLAG);
}
// 3
if (PWM_RISING[3])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP2, DRVPWM_CAP_RISING_FLAG);
}
if (PWM_FALLING[3])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP2, DRVPWM_CAP_FALLING_FLAG);
}
// 4
if (PWM_RISING[4])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP3, DRVPWM_CAP_RISING_FLAG);
}
if (PWM_FALLING[4])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP3, DRVPWM_CAP_FALLING_FLAG);
}
// 5
if (PWM_RISING[5])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP4, DRVPWM_CAP_RISING_FLAG);
}
if (PWM_FALLING[5])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP4, DRVPWM_CAP_FALLING_FLAG);
}
// 6
if (PWM_RISING[6])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP5, DRVPWM_CAP_RISING_FLAG);
}
if (PWM_FALLING[6])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP5, DRVPWM_CAP_FALLING_FLAG);
}
// 7
if (PWM_RISING[7])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP6, DRVPWM_CAP_RISING_FLAG);
}
if (PWM_FALLING[7])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP6, DRVPWM_CAP_FALLING_FLAG);
}
// 8
if (PWM_RISING[8])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP7, DRVPWM_CAP_RISING_FLAG);
}
if (PWM_FALLING[8])
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP7, DRVPWM_CAP_FALLING_FLAG);
}
}
//上电清除中断
void FIRSTCLRCAPIRQ()
{
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP0, DRVPWM_CAP_RISING_FLAG);
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP1, DRVPWM_CAP_RISING_FLAG);
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP2, DRVPWM_CAP_RISING_FLAG);
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP3, DRVPWM_CAP_RISING_FLAG);
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP4, DRVPWM_CAP_RISING_FLAG);
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP5, DRVPWM_CAP_RISING_FLAG);
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP6, DRVPWM_CAP_RISING_FLAG);
DrvPWM_ClearCaptureIntStatus(DRVPWM_CAP7, DRVPWM_CAP_RISING_FLAG);
}
//中断计数
void DRVPWM_CapIRQHandler1()
{
PWM_cnt[1]++;
}
void DRVPWM_CapIRQHandler2()
{
PWM_cnt[2]++;
}
void DRVPWM_CapIRQHandler3()
{
PWM_cnt[3]++;
}
void DRVPWM_CapIRQHandler4()
{
PWM_cnt[4]++;
}
void DRVPWM_CapIRQHandler5()
{
PWM_cnt[5]++;
}
void DRVPWM_CapIRQHandler6()
{
if (CT >0&&CT <100)
PWM_cnt[6]++;
}
void DRVPWM_CapIRQHandler7()
{
PWM_cnt[7]++;
}
void DRVPWM_CapIRQHandler8()
{
PWM_cnt[8]++;
}

#endif

2万 · 2018-3-7 14:20

#ifndef DISPLAY_H
#define DISPLAY_H
//
#include "MYFUN\MYFUN.h"
//写指令
void SendCommand(uint8_t CommandData) //Send Command
{
uint8_t i;
uint8_t iData, TempData1, TempData2;
iData = 0xf8;
TempData1 = (CommandData & 0xf0);
TempData2 = (CommandData & 0x0f);
TempData2 <<= 4;
DELAY(10);
CSL;
DELAY(10);
CLKL;
DELAY(10);
SIDL;
DELAY(10);
CSH;
DELAY(10);
for (i = 0; i < 8; i++) {
      DELAYUS(50);
if ((iData & 0x80) != 0)
SIDH;
else
SIDL;
DELAY(10);
CLKH;
DELAY(10);
CLKL;
DELAY(10);
iData = iData << 1;
}
for (i = 0; i < 8; i++) {
      DELAYUS(50);
if ((TempData1 & 0x80) != 0)
SIDH;
else
SIDL;
DELAY(10);
CLKH;
DELAY(10);
CLKL;
DELAY(10);
TempData1 <<= 1;
}
for (i = 0; i < 8; i++) {
      DELAYUS(50);
if ((TempData2 & 0x80) != 0)
SIDH;
else
SIDL;
DELAY(10);
CLKH;
DELAY(10);
CLKL;
DELAY(10);
TempData2 <<= 1;
}
CSL;
DELAY(10);
SIDH;
DELAY(10);
}
//写字节
void SendData(uint8_t CommandData) //Send Data
{
uint8_t i;
uint8_t iData, TempData1, TempData2;
iData = 0xfa;
TempData1 = (CommandData & 0xf0);
TempData2 = (CommandData & 0x0f);
TempData2 <<= 4;
DELAY(10);
CSL;
DELAY(10);
CLKL;
DELAY(10);
SIDL;
DELAY(10);
CSH;
DELAY(10);
for (i = 0; i < 8; i++) {
      DELAYUS(50);
if ((iData & 0x80) != 0)
SIDH;
else
SIDL;
DELAY(10);
CLKH;
DELAY(10);
CLKL;
DELAY(10);
iData = iData << 1;
}
for (i = 0; i < 8; i++) {
      DELAYUS(50);
if ((TempData1 & 0x80) != 0)
SIDH;
else
SIDL;
DELAY(10);
CLKH;
DELAY(10);
CLKL;
DELAY(10);
TempData1 <<= 1;
}
for (i = 0; i < 8; i++) {
      DELAYUS(50);
if ((TempData2 & 0x80) != 0)
SIDH;
else
SIDL;
DELAY(10);
CLKH;
DELAY(10);
CLKL;
DELAY(10);
TempData2 <<= 1;
}
CSL;
DELAY(10);
SIDH;
DELAY(10);

}
//初始化LCD
void InitLCD() //LCD Init
{
DELAY(50);
SendCommand(0x30);
DELAY(50);
SendCommand(0x0c);
DELAY(50);
SendCommand(0x01);
DELAY(50);
}
//刷新屏幕
void lcdclr() {
SendCommand(0x01);
SendCommand(0x34);
SendCommand(0x30);
}
//显示图画
void pic_Disp(uint8_t *pic) //显示Gdram内容（显示图片）
{
uint8_t x, y, i;
for (i = 0; i < 9; i = i + 8)
for (y = 0; y < 32; y++) {
for (x = 0; x < 8; x++) {
SendCommand(0x36); //扩充指令，开绘图显示
SendCommand(0x80 + y); //行地址
SendCommand(0x80 + x + i); //列地址
SendData(*pic++); //写数据 D15－D8
SendData(*pic++); //写数据 D7－D0
SendCommand(0x30);
}
}
}
/*****************************************
** 将一个整型数据转化为字符串
** 入口参数要转换的整型数: dataint, 数组p[10]
** 改变思路：整数 -->字符串-->加字符串结束标志
** 可以转换小于0的整数
*****************************************/
void long_to_string(long int dataint, char *p) {
long int datainttmp;
char *p1; //指向转换成为数组时用到
char datachar1[10];
char datachar2[10];
uint8_t n = 0; //取整型数据的位数
uint8_t i = 0;
uint8_t k1 = 0; //取字符个数
uint8_t k2 = 0; //取字符个数

if (dataint >= 0)
datainttmp = (long int) dataint;
else
datainttmp = (long int) dataint * (-1);

p1 = datachar2;

while (datainttmp != 0) {
datachar1[n++] = (datainttmp % 10) + 0x30; //转换为字符并取得这个整型数据的位数 n
datainttmp /= 10;
}

if (dataint > 0) //如果要转换的整型数据>0
{
k1 = n - 1;
k2 = n;

for (i = 0; i < k2; i++, k1--) {
datachar2[k1] = datachar1[i]; //将数字符串倒过来
}
datachar2[n] = '\0'; //字符串结束标志
}

else if (dataint < 0) //<0
{
k1 = n;
k2 = n + 1;

for (i = 0; i < k2; i++, k1--) {
datachar2[k1] = datachar1[i];
}
datachar2[n + 1] = '\0';
datachar2[0] = '-'; //加上负号
}

else if (dataint == 0) //=0
{
datachar2[0] = 0x30;
datachar2[1] = '\0';
}

p1 = datachar2;

strcpy(p, p1);
}
//
/*****************************************
** 将一个浮点型数据转化为字符串
** 入口参数要转换的浮点数: dataf, 数组datastr[10], 小数位数 P
** 最好小数位数不是
** 改变思路：浮点数 --> 整数 -->字符串-->根据各种类型的浮点数不同调整字符位置
** 可以转换小于0的浮点数
*****************************************/
void float_2_string(float dataf, char *datastr, uint8_t p) {
float dataftmp = dataf;
char datastr1[10];
uint8_t flag1 = 0;
uint8_t flag2 = 0;
uint8_t k;
uint8_t i = 0;

if ((long int) dataf == 0) // dataf为 -1 --- 1 之间的数
{
dataftmp += 9; //随便一个整数只是为了扩大为首位不为0的数
flag1 = 1;
if (dataf < 0) {
flag2 = 1;
dataftmp -= 9; //随便一个整数只是为了扩大为首位不为0的数
flag1 = 0;
}
}

for (i = 0; i < p + 1; i++)
dataftmp = dataftmp * 10;

long_to_string((long int) dataftmp, datastr1);
k = strlen(datastr1);

for (i = 1; i < p + 1; i++)
*(datastr1 + (k - i)) = *(datastr1 + (k - i - 1));

*(datastr1 + (k - i)) = '.';

if (flag1) //如果为0.00820之类的数
{
*datastr1 = '0';
flag1 = 0;
}

if (flag2) //如果为-0.00820之类的数
{
*datastr1 = '-';
*(datastr1 + 1) = '0';
}

if (p == 0) {
*(datastr1 + (k - i)) = '\0';
}

strcpy(datastr, datastr1);
}
//
//写中文汉字串
void DispString(uint8_t x, uint8_t y, char *string) {
switch (x) {
case 0:
SendCommand(0x80 + y);
break;
case 1:
SendCommand(0x90 + y);
break;
case 2:
SendCommand(0x88 + y);
break;
case 3:
SendCommand(0x98 + y);
break;
default:
break;
}
while (*string) {
SendData(*string);
string++;
}
}
//
void DispLongint(uint8_t x, uint8_t y, long int datalongint) {
char a[10];
long_to_string(datalongint, a);
DispString(x, y, a);
}
//写浮点型数据
void DispFloat(uint8_t x, uint8_t y, float dataf, uint8_t p) {
char a[10];
float_2_string(dataf, a, p);
DispString(x, y, a);
SendData(0x20);
SendData(0x20);
}

#endif

2万 · 2018-3-7 14:20

#ifndef _IO_H_
#define _IO_H_
//数字量输入
#define DI01 DrvGPIO_GetBit(GPB,13)

#define DI02 DrvGPIO_GetBit(GPB,12)

#define DI03 DrvGPIO_GetBit(GPD,8)

#define DI04 DrvGPIO_GetBit(GPD,9)

#define DI05 DrvGPIO_GetBit(GPD,10)

#define DI06 DrvGPIO_GetBit(GPD,11)

#define DI07 DrvGPIO_GetBit(GPD,12)

#define DI08 DrvGPIO_GetBit(GPD,13)

#define DI09 DrvGPIO_GetBit(GPB,4)

#define DI10 DrvGPIO_GetBit(GPB,5)

#define DI11 DrvGPIO_GetBit(GPB,6)

#define DI12 DrvGPIO_GetBit(GPB,7)
//130系列芯片独有
#define DI13 DrvGPIO_GetBit(GPE,8)
#define DI14 DrvGPIO_GetBit(GPE,7)
//
#define DI15 DrvGPIO_GetBit(GPE,13)

#define DI16 DrvGPIO_GetBit(GPB,14)

#define DI17 DrvGPIO_GetBit(GPB,3)

#define DI18 DrvGPIO_GetBit(GPD,6)

#define DI19 DrvGPIO_GetBit(GPD,7)

#define DI20 DrvGPIO_GetBit(GPD,14)
//获取输出状态
#define DO1 DrvGPIO_GetBit(GPE,4)
#define DO2 DrvGPIO_GetBit(GPB,9)
#define DO3 DrvGPIO_GetBit(GPB,10)
#define DO4 DrvGPIO_GetBit(GPE,6)
#define DO5 DrvGPIO_GetBit(GPC,0)
#define DO6 DrvGPIO_GetBit(GPC,1)
#define DO7 DrvGPIO_GetBit(GPC,2)
#define DO8 DrvGPIO_GetBit(GPC,3)

//数字量输出
#define DO1ON  DrvGPIO_ClrBit(GPE,4)
#define DO1OFF DrvGPIO_SetBit(GPE,4)

#define DO2ON  DrvGPIO_ClrBit(GPB,9)
#define DO2OFF DrvGPIO_SetBit(GPB,9)

#define DO3ON  DrvGPIO_ClrBit(GPB,10)
#define DO3OFF DrvGPIO_SetBit(GPB,10)

#define DO4ON  DrvGPIO_ClrBit(GPE,6)
#define DO4OFF DrvGPIO_SetBit(GPE,6)

#define DO5ON  DrvGPIO_ClrBit(GPC,0)
#define DO5OFF DrvGPIO_SetBit(GPC,0)

#define DO6ON  DrvGPIO_ClrBit(GPC,1)
#define DO6OFF DrvGPIO_SetBit(GPC,1)

#define DO7ON  DrvGPIO_ClrBit(GPC,2)
#define DO7OFF DrvGPIO_SetBit(GPC,2)

#define DO8ON  DrvGPIO_ClrBit(GPC,3)
#define DO8OFF DrvGPIO_SetBit(GPC,3)
//LCD
#define CSL  DrvGPIO_ClrBit(GPC,4)
#define CSH  DrvGPIO_SetBit(GPC,4)
#define SIDL DrvGPIO_ClrBit(GPC,5)
#define SIDH DrvGPIO_SetBit(GPC,5)
#define CLKL DrvGPIO_ClrBit(GPD,15)
#define CLKH DrvGPIO_SetBit(GPD,15)
//
#define DIR1 DrvGPIO_GetBit(GPC,8)
#define DIR2 DrvGPIO_GetBit(GPC,9)
#define DIR3 DrvGPIO_GetBit(GPC,10)
#define DIR4 DrvGPIO_GetBit(GPC,11)
#define DIR5 DrvGPIO_GetBit(GPC,12)
#define DIR6 DrvGPIO_GetBit(GPC,13)
#define DIR7 DrvGPIO_GetBit(GPE,2)
#define DIR8 DrvGPIO_GetBit(GPE,3)
//
//相位正转ON/OFF
#define XWZZON DO1ON
//相位正转启动
#define XWZZOFF DO1OFF
//相位正转停止
//相位反转ON/OFF
#define XWFZON DO2ON
//相位反转启动
#define XWFZOFF DO2OFF
//相位反转停止
//轴向正转ON/OFF
#define ZXZZON DO3ON
//轴向正转启动
#define ZXZZOFF DO3OFF
//轴向正转启动
//轴向反转ON/OFF
#define ZXFZON DO4ON
//轴向反转启动
#define ZXFZOFF DO4OFF
//轴向反转启动
//报警输出ON/OFF
#define BJON DO5ON
//报警开
#define BJOFF DO5OFF
//报警关

//输入+有指示灯
#define XWYD DI01
//相位原点
#define XWRGZ DI02
//相位热故障
#define ZXYXW DI03
//轴向右限位
#define ZXZXW DI04
//轴向左限位
#define ZXYD DI05
//轴向原点
#define ZXRGZ DI06
//轴向热故障
//键盘按钮
#define XWZXDD DI07
//相位正向点动
#define XWFXDD DI08
//相位反向点动
#define XWYW DI09
//相位原位
#define XWFH DI10
//相位返回
#define ZXZXDD DI11
//轴向正向点动
#define ZXFXDD DI12
//轴向反向点动
#define ZXYW DI13
//轴向原位
#define ZXFH DI14
//轴向返回

////输入+有指示灯
//#define XWYD DI01
////相位原点
//#define XWRGZ DI05
////相位热故障
//#define ZXYXW DI03
////轴向右限位
//#define ZXZXW DI04
////轴向左限位
//#define ZXYD DI02
////轴向原点
//#define ZXRGZ DI06
////轴向热故障
//
////键盘按钮
//#define XWZXQD DI07
////相位正向点动
//#define XWFXQD DI08
////键盘按钮
//#define XWZXDD DI09
////相位正向点动
//#define XWFXDD DI10
//
////相位反向点动
//#define XWYW DI11
////相位原位
//#define XWFH DI12
////键盘按钮
//
//#define ZXZXQD DI13
////相位正向点动
//#define ZXFXQD DI14
////相位返回
//#define ZXZXDD DI15
////轴向正向点动
//#define ZXFXDD DI16
////轴向反向点动
//#define ZXYW DI17
////轴向原位
//#define ZXFH DI18
////轴向返回
//
#endif

2万 · 2018-3-7 14:22

#ifndef _MYFUN_H_
#define _MYFUN_H_
//
#include "math.h"
//
#include "Driver\DrvGPIO.h"
#include "Driver\DrvSYS.h"
#include "Driver\DrvPWM.h"
#include "Driver\DrvTimer.h"
//
#include "nuc_pwm.h"
//
#include "MYFUN\IO.H"
#include "MYFUN\BIANMAQI.H"
#include "MYFUN\DISPLAY.H"
#include "MYFUN\TIMINIT.H"
//
//延时函数
void DELAY(uint32_t us)
{
SysTick->LOAD = us * 22; /* Assume the internal 22MHz RC used */
SysTick->VAL = (0x00);
SysTick->CTRL = (1 << 2) | (1 << 0);
while ((SysTick->CTRL & (1 << 16)) == 0)
;
}
//us级延时
void DELAYUS(uint32_t us)
{
while (us--)
{
__NOP();
__NOP();
}
}
//系统初始化
void SYSinit()
{
UNLOCKREG();
SYSCLK->PLLCON.OE = 0;
SYSCLK->PWRCON.XTL12M_EN = 1;
DrvSYS_SetPLLPowerDown(0);
DELAY(1000);
DrvSYS_SetHCLKSource(2);
DELAY(100);
SystemFrequency = 48000000;
}
#endif

2万 · 2018-3-7 14:23

#ifndef _TIMINIT_H
#define _TIMINIT_H
#include "MYFUN\BIANLIANGBIAO.H"
//
void TimerInit(void)
{
uint32_t timerClkSrc;
TIMER_TCSR_T tcsr =
{
0
};
/* Configure GCR to reset Timer */
SYS->IPRSTC2.TMR0_RST = 1;
SYS->IPRSTC2.TMR0_RST = 0;
SYS->IPRSTC2.TMR1_RST = 1;
SYS->IPRSTC2.TMR1_RST = 0;
SYS->IPRSTC2.TMR2_RST = 1;
SYS->IPRSTC2.TMR2_RST = 0;
SYS->IPRSTC2.TMR3_RST = 1;
SYS->IPRSTC2.TMR3_RST = 0;

/* Enable Timer clock */
SYSCLK->APBCLK.TMR0_EN = 1;
SYSCLK->APBCLK.TMR1_EN = 1;
SYSCLK->APBCLK.TMR2_EN = 1;
SYSCLK->APBCLK.TMR3_EN = 1;

/* Select Timer clock source */
SYSCLK->CLKSEL1.TMR0_S = 0;
SYSCLK->CLKSEL1.TMR1_S = 0;
SYSCLK->CLKSEL1.TMR2_S = 0;
SYSCLK->CLKSEL1.TMR3_S = 0; /* 22Mhz clock source */

timerClkSrc = 12000000;

/* Timer reload value */
TIMER0->TCMPR = timerClkSrc / 12000;
TIMER1->TCMPR = timerClkSrc / 12000;
TIMER2->TCMPR = timerClkSrc / 12000;
TIMER3->TCMPR = timerClkSrc / 12000;

/* Start timer */
tcsr.nDBGACK_EN = 1;
tcsr.IE = 1;
tcsr.CACT = 1;
tcsr.CRST = 1;
tcsr.CEN = 1;
tcsr.PRESCALE = 0;
tcsr.TDR_EN = 1;
tcsr.MODE = 1;
REGCOPY(TIMER0->TCSR, tcsr);
REGCOPY(TIMER1->TCSR, tcsr);
REGCOPY(TIMER2->TCSR, tcsr);
REGCOPY(TIMER3->TCSR, tcsr);

NVIC_SetPriority(TMR0_IRQn, (1 << __NVIC_PRIO_BITS) - 0);
NVIC_SetPriority(TMR1_IRQn, (1 << __NVIC_PRIO_BITS) - 1);
NVIC_SetPriority(TMR2_IRQn, (1 << __NVIC_PRIO_BITS) - 2);
NVIC_SetPriority(TMR3_IRQn, (1 << __NVIC_PRIO_BITS) - 3);

NVIC_EnableIRQ(TMR0_IRQn);
NVIC_EnableIRQ(TMR1_IRQn);
NVIC_EnableIRQ(TMR2_IRQn);
NVIC_EnableIRQ(TMR3_IRQn);
}
//

void TMR0_IRQHandler(void) // Timer0 interrupt subroutine
{
CT++;
if (CT >= 100)
{
CT = 0;
}
TIMER0->TISR.TIF = 1;
}
////判断相位运动
//void TMR1_IRQHandler(void)
// {
// TIMER1->TISR.TIF = 1;
// }
////判断轴向运动
//void TMR2_IRQHandler(void)
// {
//
// TIMER2->TISR.TIF = 1;
// }
////
//void TMR3_IRQHandler(void)
// {
// TIMER3->TISR.TIF = 1;
// }
//
#endif

2万 · 2018-3-7 14:25

/********************************************************************************************************//**
* @brief    This function is used to enable/disable PWM0~7 timer/capture I/O function
* @param[in]  u8Timer  : DRVPWM_TIMER0 / DRVPWM_TIMER1 / DRVPWM_TIMER2 / DRVPWM_TIMER3
*                         DRVPWM_TIMER4 / DRVPWM_TIMER5 / DRVPWM_TIMER6 / DRVPWM_TIMER7
*                         DRVPWM_CAP0 / DRVPWM_CAP1 / DRVPWM_CAP2 / DRVPWM_CAP3
*                         DRVPWM_CAP4 / DRVPWM_CAP5 / DRVPWM_CAP6 / DRVPWM_CAP7
* @param[in]  i32Enable :  Enable  (1) / Disable  (0)
* @return None
************************************************************************************************************/
void DrvPWM_SetTimerIO(uint8_t u8Timer, int32_t i32Enable)
{
if (i32Enable)
{
      if (u8Timer & 0x10)
      {
         if (u8Timer & 0x04)
            PWMB->CAPENR = PWMB->CAPENR | (1 << (u8Timer - DRVPWM_CAP4));
         else
            PWMA->CAPENR = PWMA->CAPENR | (1 << (u8Timer & 0x07));
      }
      else
      {
         switch (u8Timer)
         {
            case DRVPWM_TIMER0:
                  REG32WRITE(PWMA->POE, PWM0, 1);
                  break;
            case DRVPWM_TIMER1:
                  REG32WRITE(PWMA->POE, PWM1, 1);
                  break;
            case DRVPWM_TIMER2:
                  REG32WRITE(PWMA->POE, PWM2, 1);
                  break;
            case DRVPWM_TIMER3:
                  REG32WRITE(PWMA->POE, PWM3, 1);
                  break;
            case DRVPWM_TIMER4:
                  REG32WRITE(PWMB->POE, PWM0, 1);
                  break;
            case DRVPWM_TIMER5:
                  REG32WRITE(PWMB->POE, PWM1, 1);
                  break;
            case DRVPWM_TIMER6:
                  REG32WRITE(PWMB->POE, PWM2, 1);
                  break;
            case DRVPWM_TIMER7:
                  REG32WRITE(PWMB->POE, PWM3, 1);
                  break;
         }
      }
}
else
{
      if (u8Timer & 0x10)
      {
         if (u8Timer & 0x04)
            PWMB->CAPENR = PWMB->CAPENR & ~(1 << (u8Timer & 0x07));
         else
            PWMA->CAPENR = PWMA->CAPENR & ~(1 << (u8Timer & 0x07));
      }
      else
      {
         switch (u8Timer)
         {
            case DRVPWM_TIMER0:
                  REG32WRITE(PWMA->POE, PWM0, 0);
                  break;
            case DRVPWM_TIMER1:
                  REG32WRITE(PWMA->POE, PWM1, 0);
                  break;
            case DRVPWM_TIMER2:
                  REG32WRITE(PWMA->POE, PWM2, 0);
                  break;
            case DRVPWM_TIMER3:
                  REG32WRITE(PWMA->POE, PWM3, 0);
                  break;
            case DRVPWM_TIMER4:
                  REG32WRITE(PWMB->POE, PWM0, 0);
                  break;
            case DRVPWM_TIMER5:
                  REG32WRITE(PWMB->POE, PWM1, 0);
                  break;
            case DRVPWM_TIMER6:
                  REG32WRITE(PWMB->POE, PWM2, 0);
                  break;
            case DRVPWM_TIMER7:
                  REG32WRITE(PWMB->POE, PWM3, 0);
                  break;
         }
      }
}
}

2万 · 2018-3-7 14:26

/********************************************************************************************************//**
* @brief    The function is used to Enable PWM engine clock and reset PWM
* @param[in] None
* @return None
************************************************************************************************************/
void DrvPWM_Open(void)
{
REG32WRITE(SYSCLK->APBCLK, PWM01_EN, 1);
REG32WRITE(SYSCLK->APBCLK, PWM23_EN, 1);
REG32WRITE(SYSCLK->APBCLK, PWM45_EN, 1);
REG32WRITE(SYSCLK->APBCLK, PWM67_EN, 1);
REG32WRITE(SYS->IPRSTC2, PWM03_RST,  1);
REG32WRITE(SYS->IPRSTC2, PWM03_RST,  0);
REG32WRITE(SYS->IPRSTC2, PWM47_RST,  1);
REG32WRITE(SYS->IPRSTC2, PWM47_RST,  0);
}

2万 · 2018-3-7 14:27

/********************************************************************************************************//**
* @brief The function is used to Disable PWM engine clock and the I/O enable
* @param[in] None
* @return None
************************************************************************************************************/
void DrvPWM_Close(void)
{
REG32WRITE(PWMA->POE, PWM0, 0);
REG32WRITE(PWMA->POE, PWM1, 0);
REG32WRITE(PWMA->POE, PWM2, 0);
REG32WRITE(PWMA->POE, PWM3, 0);
PWMA->CAPENR = 0;

REG32WRITE(PWMB->POE, PWM0, 0);
REG32WRITE(PWMB->POE, PWM1, 0);
REG32WRITE(PWMB->POE, PWM2, 0);
REG32WRITE(PWMB->POE, PWM3, 0);
PWMB->CAPENR = 0;

NVIC_DisableIRQ(PWMA_IRQn);
NVIC_DisableIRQ(PWMB_IRQn);

REG32WRITE(SYS->IPRSTC2, PWM03_RST, 1);
REG32WRITE(SYS->IPRSTC2, PWM03_RST, 0);
REG32WRITE(SYS->IPRSTC2, PWM47_RST, 1);
REG32WRITE(SYS->IPRSTC2, PWM47_RST, 0);

REG32WRITE(SYSCLK->APBCLK, PWM01_EN, 0);
REG32WRITE(SYSCLK->APBCLK, PWM23_EN, 0);
REG32WRITE(SYSCLK->APBCLK, PWM45_EN, 0);
REG32WRITE(SYSCLK->APBCLK, PWM67_EN, 0);
}

PWM测试编码器速度

技术奇才奖章

伴坛终老