STC8H单片机硬件触摸按键的简单实现（2）——代码分享

慕名而来 · 发表于 2022-11-10 11:06:51

爱科技、爱创意、爱折腾、爱极致，我们都是技术控

您需要登录才可以下载或查看，没有账号？立即注册

x

本帖最后由慕名而来于 2022-11-10 12:48 编辑

昨天发帖：STC8H单片机硬件触摸按键的简单实现（1）——官方例程与配置软件https://www.mydigit.cn/thread-353279-1-1.html(出处: 数码之家)，说了一下STC8H单片机硬件触摸按键编程的前期准备——查看串口数据、确定按键状态值，接下来完成这段应用程序。
长居本坛的朋友或许知道，我基本上只玩STC的51单片机，虽然也弄了十几年了，但经常只是做些时钟、万年历这些单片机地皮级的应用，C编程一直都是座门墩的水平始终没能登堂入室，很多时候都是在做用例程、改例程、简化例程的所谓编程，真的不会自己起头写代码，这段触摸按键代码也不例外，只是以最简单的代码实现了最基本的使用功能，因为应用模式为按键自动重复检测模式，所以，这段代码整合的其他工程里应用时是否会出现分时冲突还不知道，我也试图测试单次检测模式但没能实现，在此也希望高手指点。

/**********************************************************************
//如有转载请注明出处
//代码原创：wannenggong 2022-11-10
//单片机型号：STC8H4K64TL，电源电压3.3V，使用外接RX8025T-32768信号源做外部晶振
//接线方式：P1.1口经1K电阻连接金属触摸片，P1.0口经470Ω电阻连接LED到正电源
//触摸按键工作模式：自动重复扫描
//实验目标：触摸按键时LED亮起，不触摸按键时LED熄灭
***********************************************************************/
#include "STC8H.h" //包含了u8、u16、u32的定义
#include <intrins.h>
sbit wng_led=P1^0;
//------------------------------------------
void key_init()
{
P_SW2 |= 0x80; //允许访问XFR
TSRT = 0x00; //不开启LED驱动分时功能
TSCHEN1 = 0x02; //仅使能TK01(P1.1)
TSCHEN2 = 0x00; //其他按键没有使用
TSCFG1 = (7<<4) + 3; //开关电容工作频率 = fosc/(2*(TSCFG1[6:4]+1)), 放电时间(系统时钟周期数) 0(125) 1(250) 2(500) 3(1000) 4(2000) 5(2500) 6(5000) 7(7500) 最小3
TSCFG2 = 2; //配置触摸按键控制器的内部参考电压(AVCC的分压比), 0(1/4) 1(1/2) 2(5/8) 3(3/4)
TSWUTC = 0x0c; //32768/(32*8*0x0c)=10Hz=100ms唤醒一次
TSCTRL = 0xB0; //使用外部晶振
// TSCTRL = 0xA0; //使用内部晶振
//----TSCTRL寄存器详解如下--------------
//B7:TSGO=1使能触摸按键
//B6:SINGLE=1单次扫描模式、=0自动重复扫描
//B5:TSWAIT=1完成一轮扫描后、TSIF 被硬件置 1，此时触摸按键控制器会暂停扫描，直到 TSIF 标志位被清 0后才开始下一轮的扫描
//B4:TSWUCS=0使用内部32K晶振
//B3:TSDCEN=0不使能16位比较器
//B2:TSWUEN=1使能低功耗唤醒功能
//B1B0:TSSAMP=11单次按键扫描4次
//--------------------------------------
P_SW2 &= ~0x80; //禁止访问XFR
//IE2 |= 0x80;
}
//----键值读取函数--------------------
u8 Read_Key_value(void)
{
u8 j,wng_data;
u16 i, wng_value=0;
P_SW2 |= 0x80;
for(i=0; i<100; i++)
{
j = TSSTA2;
if(j & 0x40) //数据溢出
{
TSSTA2 |= 0x40; //写1清零
wng_value=0xee; //返回错误码0xee
}
if(j & 0x80) //扫描完成
{
TSSTA2 |= 0x80; //写1清零
wng_value=TSDAT;
wng_data=wng_value>>12; //获取高8位数据的高4位用于判断
}
}
P_SW2 &= ~0x80;
return (wng_data);
}
//----按键函数------------------------------
void key01()
{
u8 wng;
wng=Read_Key_value();
if(wng==0xee)
return;
else
{
if(wng<0x03) //选取一个中值用来判断按键状态
wng_led=0;
else if(wng>0x03)
wng_led=1;
}
}
//------------------------------------------
void main(void)
{
P1M1=0x00;
P1M0=0x00;
P3M1=0x00;
P3M0=0x00;
P5M1=0x00;
P5M0=0x00;
key_init();
wng_led=1;
while(1)
{
key01();
}
}

复制代码

zhang_yy007 · 发表于 2022-11-10 11:29:55

本帖最后由 zhang_yy007 于 2022-11-10 11:34 编辑

这个原理就是通过ADC读取电压变化然后判断是否触摸吧需要根据数据手册查看寄存器的配置是否够准确这个自己慢慢研究一下就可以了你这水平不行呀，人家用的是内部时钟自动调用，你怕有影响加入中断调一下时序就可以了

fsss007 · 发表于 2022-11-10 11:31:06

谢谢分享，可以实现双击和单击吗？长按短按？

wfzdm · 发表于 2022-11-10 11:45:23

多谢分享

mmxx2015 · 发表于 2022-11-10 11:55:24

zhang_yy007 发表于 2022-11-10 11:29
这个原理就是通过ADC读取电压变化然后判断是否触摸吧需要根据数据手册查看寄存器的配置是否够准确这 ...

从框图看，这颗芯片用的是电荷搬移原理，检测的是搬移时间。

慕名而来 · 发表于 2022-11-10 12:02:28

zhang_yy007 发表于 2022-11-10 11:29
这个原理就是通过ADC读取电压变化然后判断是否触摸吧需要根据数据手册查看寄存器的配置是否够准确这 ...

多谢指点，关于32786KHz时钟使用内部时钟还是外部时钟只是因为我用来测试代码的板子上已经集成了RX8025T所以最终就用外部时钟了，我这次实验没用到中断，有时间测试一下中断调整时序的方法。

慕名而来 · 发表于 2022-11-10 12:04:36

fsss007 发表于 2022-11-10 11:31
谢谢分享，可以实现双击和单击吗？长按短按？

只是实现了按键的基本功能，还没有进行其他测试，有兴趣的话可以玩一玩而后大家分享经验。

ljlj2001 · 发表于 2022-11-10 12:11:13

过来学习一下

STC32位8051 · 发表于 2022-11-10 15:48:15

谢谢楼主的分享，STC8H4K64TL芯片的外部RTC并且在TFT上显示，正常运行。

慕名而来 · 发表于 2022-11-19 12:16:00

本帖最后由慕名而来于 2022-11-19 12:27 编辑

一直在弄这个硬件触摸按键，但总是不能透彻，我真的想知道STC8H这个是怎样触发“触摸”中断的，或者说它究竟有没有“触摸触发中断的功能”，问题详见下图：

希望有了解STC触摸按键应用的朋友能够指点一下，先谢了！

慕名而来 · 发表于 2022-11-19 12:21:05

慕名而来发表于 2022-11-19 12:16
一直在弄这个硬件触摸按键，但总是不能透彻，我真的想知道STC8H这个是怎样触发“触摸”中断的，或者说它究 ...

下面是我参照的代码，也就是上一篇附近中的代码:

/*---------------------------------------------------------------------*/
/* --- STC MCU Limited ------------------------------------------------*/
/* --- STC 1T Series MCU Demo Programme -------------------------------*/
/* --- Mobile: (86)13922805190 ----------------------------------------*/
/* --- Fax: 86-0513-55012956,55012947,55012969 ------------------------*/
/* --- Tel: 86-0513-55012928,55012929,55012966 ------------------------*/
/* --- Web: www.STCMCU.com --------------------------------------------*/
/* --- Web: www.STCMCUDATA.com ---------------------------------------*/
/* --- QQ: 800003751 -------------------------------------------------*/
/* 如果要在程序中使用此代码,请在程序中注明使用了STC的资料及程序 */
/*---------------------------------------------------------------------*/
#include <intrins.h>
#include "STC8Hxxxxx.h"
/************* 功能说明 **************
通过串口(P3.0 P3.1)发送指令配置触摸按键, 以及获取触摸按键数值.
P1.0(TK00) P1.1(TK01) P5.4(TK02) P1.3(TK03) P1.4(TK04) P1.5(TK05) P1.6(TK06) P1.7(TK07)
P5.0(TK08) P5.1(TK09) P5.2(TK10) P5.3(TK11) P0.0(TK12) P0.1(TK13) P0.2(TK14) P0.3(TK15)
串口默认设置: 115200,N,8,1.
上电后先读键，将此时的读数作为零点.
下载时, 选择时钟 22.1184MHz (用户可自行修改频率).
******************************************/
/************* 本地常量声明 **************/
//不同型号芯片特殊参数在存储器中保存的地址不同，详情请参考规格书7.3章节
#define ID_ROMADDR ((unsigned char code *)0xfdf9)
#define VREF_ROMADDR (*(unsigned int code *)0xfdf7)
#define F32K_ROMADDR (*(unsigned int code *)0xfdf5)
#define T22M_ROMADDR (*(unsigned char code *)0xfdf4) //22.1184MHz (27M频段)
#define T24M_ROMADDR (*(unsigned char code *)0xfdf3) //24MHz (27M频段)
#define T20M_ROMADDR (*(unsigned char code *)0xfdf2) //20MHz (27M频段)
#define T27M_ROMADDR (*(unsigned char code *)0xfdf1) //27MHz (27M频段)
#define T30M_ROMADDR (*(unsigned char code *)0xfdf0) //30MHz (27M频段)
#define T33M_ROMADDR (*(unsigned char code *)0xfdef) //33MHz (27M频段)
#define T35M_ROMADDR (*(unsigned char code *)0xfdee) //35MHz (44M频段)
#define T36M_ROMADDR (*(unsigned char code *)0xfded) //36MHz (44M频段)
#define T40M_ROMADDR (*(unsigned char code *)0xfdec) //40MHz (44M频段)
#define VRT6M_ROMADDR (*(unsigned char code *)0xfdea) //VRTRIM_6MHz
#define VRT10M_ROMADDR (*(unsigned char code *)0xfde9) //VRTRIM_10MHz
#define VRT27M_ROMADDR (*(unsigned char code *)0xfde8) //VRTRIM_27MHz
#define VRT44M_ROMADDR (*(unsigned char code *)0xfde7) //VRTRIM_44MHz
#define Baudrate 115200L
#define SYNC1 0x55
#define SYNC2 0x54
typedef enum
{
CMD_SYNC1 = 0,/*0*/
CMD_SYNC2, /*1*/
CMD_TYPE, /*2*/
CMD_TSCHEN1, /*3*/
CMD_TSCHEN2, /*4*/
CMD_TSCFG1, /*5*/
CMD_TSCFG2, /*6*/
CMD_TSCTRL, /*7*/
CMD_TSRT, /*8*/
CMD_SFREQ1, /*9*/
CMD_SFREQ2, /*10*/
CMD_TSWUTC, /*11*/
CMD_TSTH00H,
CMD_TSTH00L,
CMD_TSTH01H,
CMD_TSTH01L,
CMD_TSTH02H,
CMD_TSTH02L,
CMD_TSTH03H,
CMD_TSTH03L,
CMD_TSTH04H,
CMD_TSTH04L,
CMD_TSTH05H,
CMD_TSTH05L,
CMD_TSTH06H,
CMD_TSTH06L,
CMD_TSTH07H,
CMD_TSTH07L,
CMD_TSTH08H,
CMD_TSTH08L,
CMD_TSTH09H,
CMD_TSTH09L,
CMD_TSTH10H,
CMD_TSTH10L,
CMD_TSTH11H,
CMD_TSTH11L,
CMD_TSTH12H,
CMD_TSTH12L,
CMD_TSTH13H,
CMD_TSTH13L,
CMD_TSTH14H,
CMD_TSTH14L,
CMD_TSTH15H,
CMD_TSTH15L,
CMD_CS,
CMD_LEN,
}CMD_IndexType;
typedef enum
{
IRC_500K = 0, /*0*/
IRC_1M,
IRC_2M,
IRC_3M,
IRC_5M,
IRC_6M,
IRC_8M,
IRC_10M,
IRC_11M,
IRC_12M,
IRC_15M,
IRC_18M,
IRC_20M,
IRC_22M,
IRC_24M,
IRC_27M,
IRC_30M,
IRC_33M,
IRC_35M,
IRC_36M,
}IRC_IndexType;
/************* IO口定义 **************/
sbit P_RUN_LED = P3^4;
sbit P_K0_LED = P2^5;
sbit P_K1_LED = P0^7;
sbit P_K2_LED = P4^1;
sbit P_K3_LED = P2^1;
sbit P_K4_LED = P2^2;
sbit P_K5_LED = P4^6;
sbit P_K6_LED = P2^4;
sbit P_K7_LED = P0^5;
sbit P_K8_LED = P4^2;
sbit P_K9_LED = P4^3;
sbit P_K10_LED = P2^3;
sbit P_K11_LED = P4^5;
sbit P_K12_LED = P2^0;
sbit P_K13_LED = P2^7;
sbit P_K14_LED = P2^6;
sbit P_K15_LED = P0^6;
/************* 本地变量声明 **************/
u8 CLK_ID = IRC_22M;
u32 MAIN_Fosc = 22118400L; //定义主时钟
bit B_TX1_Busy; // 发送忙标志
bit B_Zero_Flag;
bit B_1ms; //1ms标志
u16 ChannelSet;
u8 TK_TimeOut;
u8 read_cnt;
u16 tpFlag;
u16 JudgeFlag;
u16 xdata TK_cnt[16];
u16 xdata TK_zero[16];
u16 xdata TK_differ[16];
u16 xdata TK_lowest[16];
u8 xdata Zero_Add_Cnt[16];
u8 xdata Zero_Sub_Cnt[16];
u8 xdata TK_counter[16];
u8 xdata SendBuffer[CMD_LEN];
u8 xdata RX1_Buffer[CMD_LEN]; //接收缓冲
u8 RX1_TimeOut;
u8 RX1_Cnt; //接收计数
u16 ScanFreq; //扫描频次
//TP0 TP1 TP2 TP3 TP4 TP5 TP6 TP7 TP8 TP9 TP10 TP11 TP12 TP13 TP14 TP15 差值 / 2
u16 code DIFF[]={1100, 1400, 800, 600, 600, 850, 850, 1200, 850, 1000, 800, 900, 550, 600, 900, 1200}; //检测阈值=(未触摸值-触摸值)/2
/************* 本地函数声明 **************/
void Timer0_init(u32 clk);
void UART1_config(u32 clk, u32 brt); //clk: 系统主频 brt: 通信波特率
void UART1_PrintString(u8 *puts);
void UART1_TxByte(u8 dat);
void JudgeKey(u8 tkn);
void RX1_Check(void);
void ReadZeroData(void);
u8 GetCheckSum(u8 *buf, u8 len);
/**************** 外部函数声明和外部变量声明 *****************/
/******************** 主函数 **************************/
void main(void)
{
u8 i;
P0M1 = 0x0f; P0M0 = 0xe0; //设置P0.0~P0.3为高阻输入; P0.5~P0.7为推挽输出
P1M1 = 0xff; P1M0 = 0x00; //设置为高阻输入
P2M1 = 0x00; P2M0 = 0xff; //设置为推挽输出
P3M1 = 0x00; P3M0 = 0x10; //设置P3.4为推挽输出
P4M1 = 0x00; P4M0 = 0x6e; //设置P4.1~P4.3,P4.5,P4.6为推挽输出
P5M1 = 0x0f; P5M0 = 0x00; //设置P5.0~P5.3为高阻输入
P_RUN_LED = 1;
P_K0_LED = 0; P_K4_LED = 0; P_K8_LED = 0; P_K12_LED = 0;
P_K1_LED = 0; P_K5_LED = 0; P_K9_LED = 0; P_K13_LED = 0;
P_K2_LED = 0; P_K6_LED = 0; P_K10_LED = 0; P_K14_LED = 0;
P_K3_LED = 0; P_K7_LED = 0; P_K11_LED = 0; P_K15_LED = 0;
Timer0_init(MAIN_Fosc/1000); //Timer 0 中断频率, 1000次/秒
P_SW2 |= 0x80; //允许访问XSF
// MCLKOCR = 0x02; //从P5.4输出主频/2
TSRT = 0x00; //没有LED分时扫描
TSCHEN1 = 0x46; //TK00~TK07
TSCHEN2 = 0x00; //TK08~TK15
TSCFG1 = 0x7f;//(7<<4) + 3; //开关电容工作频率 = fosc/(2*(TSCFG1[6:4]+1)), 放电时间(系统时钟周期数) 0(125) 1(250) 2(500) 3(1000) 4(2000) 5(2500) 6(5000) 7(7500) 最小3
TSCFG2 = 0x02; //配置触摸按键控制器的内部参考电压(AVCC的分压比), 0(1/4) 1(1/2) 2(5/8) 3(3/4)
TSCTRL = 0xA0; //开始自动扫描, 无平均, B7: TSGO, B6: SINGLE, B5: TSWAIT, B4: TSWUCS, B3: TSDCEN, B2: TSWUEN, B1 B0: TSSAMP
// TSCTRL = (1<<7) + (1<<6); //开始单次扫描, 无平均
// TSCTRL = (1<<7) + (1<<6)+3; //开始单次扫描, 4次平均
// TSCTRL = (1<<7) + (1<<6)+1; //开始单次扫描, 2次平均
TSWUTC = 0;//12; //100ms唤醒一次
IE2 |= 0x80; //使能触摸中断
// P_SW2 &= ~0x80; //禁止访问xsf
UART1_config(MAIN_Fosc, Baudrate);
EA = 1; //允许全局中断
UART1_PrintString("STC8H4K64Txx 触摸按键测试程序\r\n");
for(i=0; i<16; i++)
{
TK_differ[i] = DIFF[i]; //设置初始差值
TK_lowest[i] = DIFF[i]*3; //设置初始下限值, 检测下限 = 阈值*3
TK_counter[i] = 0;
Zero_Sub_Cnt[i] = 0;
Zero_Add_Cnt[i] = 0;
}
tpFlag = 0;
JudgeFlag = 0;
read_cnt=0;
TK_TimeOut = 0;
B_Zero_Flag = 1;
ChannelSet = ((u16)TSCHEN2 << 8) | TSCHEN1;
ScanFreq = 50; //设置有效触摸按键持续检测时间
SendBuffer[0] = SYNC1; //初始化同步头
SendBuffer[1] = SYNC2;
while (1)
{
ReadZeroData();
/*
if(B_1ms)
{
B_1ms = 0;
for(i=0;i<16;i++)
{
JudgeKey(i); //判断键值
}
B = (u8)tpFlag;
if(B0) P_K0_LED = ~P_K0_LED;
if(B1) P_K1_LED = ~P_K1_LED;
if(B2) P_K2_LED = ~P_K2_LED;
if(B3) P_K3_LED = ~P_K3_LED;
if(B4) P_K4_LED = ~P_K4_LED;
if(B5) P_K5_LED = ~P_K5_LED;
if(B6) P_K6_LED = ~P_K6_LED;
if(B7) P_K7_LED = ~P_K7_LED;
B = (u8)(tpFlag >> 8);
if(B0) P_K8_LED = ~P_K8_LED;
if(B1) P_K9_LED = ~P_K9_LED;
if(B2) P_K10_LED = ~P_K10_LED;
if(B3) P_K11_LED = ~P_K11_LED;
if(B4) P_K12_LED = ~P_K12_LED;
if(B5) P_K13_LED = ~P_K13_LED;
if(B6) P_K14_LED = ~P_K14_LED;
if(B7) P_K15_LED = ~P_K15_LED;
tpFlag = 0;
if(RX1_TimeOut > 0)
{
if(--RX1_TimeOut == 0) //超时,则串口接收结束
{
if(RX1_Cnt > 0)
{
RX1_Check(); //处理串口1接收数据
}
RX1_Cnt = 0;
}
}
}
*/
}
}
//========================================================================
// 函数: void JudgeKey(u8 tkn)
// 描述: 判断键值是否有效。
// 参数: tkn: 按键序号.
// 返回: none.
// 版本: VER1.0
// 日期: 2010-12-15
// 备注:
//========================================================================
void JudgeKey(u8 tkn)
{
if(tkn > 15) return; //序号错误
if(ChannelSet & (1<<tkn))
{
if(TK_cnt[tkn] > TK_zero[tkn])
{
Zero_Sub_Cnt[tkn] = 0;
if(Zero_Add_Cnt[tkn] < 10)
{
Zero_Add_Cnt[tkn]++;
}
else
{
TK_zero[tkn] += 1; //零点追踪
}
if(TK_counter[tkn] > 0)
{
TK_counter[tkn]--;
}
else
{
JudgeFlag &= ~(1<<tkn); //清除触摸标志
tpFlag &= ~(1<<tkn); //清除触摸标志
}
}
else if(TK_cnt[tkn] <= (TK_zero[tkn]-TK_differ[tkn])) //判断键的阈值.
{
Zero_Sub_Cnt[tkn] = 0;
Zero_Add_Cnt[tkn] = 0;
if(TK_cnt[tkn] <= (TK_zero[tkn]-TK_lowest[tkn])) //键值超过下限.
{
//超出正常触摸值范围，判定为干扰输入
TK_counter[tkn] = 0;
}
else if((JudgeFlag & (1<<tkn)) == 0)
{
TK_counter[tkn]++;
if(TK_counter[tkn] > ScanFreq)
{
JudgeFlag |= (1<<tkn); //设置触摸标志
tpFlag |= (1<<tkn);
}
}
}
else
{
Zero_Add_Cnt[tkn] = 0;
if(Zero_Sub_Cnt[tkn] < 100 ) //延缓零点追踪
{
Zero_Sub_Cnt[tkn]++;
}
else
{
if(TK_cnt[tkn] < TK_zero[tkn]) //延缓零点追踪
{
TK_zero[tkn] -= 1; //零点追踪
Zero_Sub_Cnt[tkn] = 0;
}
}
if(TK_counter[tkn] > 0)
{
TK_counter[tkn]--;
}
else
{
JudgeFlag &= ~(1<<tkn); //清除触摸标志
tpFlag &= ~(1<<tkn); //清除触摸标志
}
}
}
}
//========================================================================
// 函数: void ReadZeroData(void)
// 描述: 获取触摸按键的零值。
// 参数: none.
// 返回: none.
// 版本: VER1.0
// 日期: 2021-02-02
// 备注:
//========================================================================
void ReadZeroData(void)
{
u8 i;
if(B_Zero_Flag)
{
TK_TimeOut++;
if(TK_TimeOut > 250) //扫描超时
{
TK_TimeOut = 0;
read_cnt++;
}
if(read_cnt > 100)
{
for(i=0; i<16; i++)
{
TK_zero[i] = TK_cnt[i]; //保存0点
TK_counter[i] = 0;
}
B_Zero_Flag = 0;
}
}
}
//========================================================================
// 函数: void UART1_config(u32 clk, u32 brt)
// 描述: UART1初始化函数。
// 参数: clk: 系统主频.
// brt: 通信波特率.
// 返回: none.
// 版本: VER1.0
// 日期: 2021-7-29
// 备注:
//========================================================================
void UART1_config(u32 clk, u32 brt)
{
brt = 65536UL - (clk / 4) / brt;
TR1 = 0;
AUXR &= ~0x01; //S1 BRT Use Timer1;
AUXR |= (1<<6); //Timer1 set as 1T mode
TMOD &= ~(1<<6); //Timer1 set As Timer
TMOD &= ~0x30; //Timer1_16bitAutoReload;
TH1 = (u8)(brt >> 8);
TL1 = (u8)brt;
ET1 = 0; // 禁止Timer1中断
INTCLKO &= ~0x02; // Timer1不输出高速时钟
TR1 = 1; // 运行Timer1
P_SW1 &= 0x3f;
P_SW1 |= 0x00; //UART1 switch to, 0x00: P3.0 P3.1, 0x40: P3.6 P3.7, 0x80: P1.6 P1.7, 0xC0: P4.3 P4.4
SCON = (SCON & 0x3f) | (1<<6); // 8位数据, 1位起始位, 1位停止位, 无校验
// PS = 1; //高优先级中断
ES = 1; //允许中断
REN = 1; //允许接收
B_TX1_Busy = 0;
RX1_Cnt = 0;
}
//========================================================================
// 函数: void UART1_TxByte(u8 dat)
// 描述: 串口1发送一个字节函数
// 参数: dat: 要发送的数据.
// 返回: none.
// 版本: VER1.0
// 日期: 2018-4-2
// 备注:
//========================================================================
void UART1_TxByte(u8 dat)
{
B_TX1_Busy = 1; //标志发送忙
SBUF = dat; //发一个字节
while(B_TX1_Busy); //等待发送完成
}
//========================================================================
// 函数: void UART1_PrintString(u8 *puts)
// 描述: 串口1字符串打印函数
// 参数: puts: 字符串指针.
// 返回: none.
// 版本: VER1.0
// 日期: 2018-4-2
// 备注:
//========================================================================
void UART1_PrintString(u8 *puts)
{
for (; *puts != 0; puts++)
{
UART1_TxByte(*puts);
}
}
//========================================================================
// 函数: void UART1_int (void) interrupt UART1_VECTOR
// 描述: 串口1中断函数
// 参数: none.
// 返回: none.
// 版本: VER1.0
// 日期: 2018-4-2
// 备注:
//========================================================================
void UART1_int (void) interrupt UART1_VECTOR
{
if(RI)
{
RI = 0;
if(RX1_Cnt >= CMD_LEN) RX1_Cnt = 0;
RX1_Buffer[RX1_Cnt] = SBUF;
RX1_Cnt++;
RX1_TimeOut = 5;
}
if(TI)
{
TI = 0;
B_TX1_Busy = 0;
}
}
//========================================================================
// 函数: void Timer0_init(void)
// 描述: timer0初始化函数.
// 参数: none.
// 返回: none.
// 版本: V1.0, 2015-1-12
//========================================================================
void Timer0_init(u32 clk)
{
TR0 = 0; //停止计数
ET0 = 1; //允许中断
// PT0 = 1; //高优先级中断
TMOD &= ~0x03;
TMOD |= 0; //工作模式, 0: 16位自动重装, 1: 16位定时/计数, 2: 8位自动重装, 3: 16位自动重装, 不可屏蔽中断
// TMOD |= 0x04; //对外计数或分频
TMOD &= ~0x04; //定时
// INTCLKO |= 0x01; //输出时钟
INTCLKO &= ~0x01; //不输出时钟
if (clk < 65536UL)
{
AUXR |= 0x80; //1T mode
TH0 = (u8)((65536UL - clk) / 256);
TL0 = (u8)((65536UL - clk) % 256);
}
else
{
AUXR &= ~0x80; //12T mode
TH0 = (u8)((65536UL - clk/12) / 256);
TL0 = (u8)((65536UL - clk/12) % 256);
}
TR0 = 1; //开始运行
}
//========================================================================
// 函数: void timer0_int (void) interrupt TIMER0_VECTOR
// 描述: timer0中断函数.
// 参数: none.
// 返回: none.
// 版本: V1.0, 2015-1-12
//========================================================================
void timer0_int (void) interrupt 1
{
B_1ms = 1; //1ms标志
}
//========================================================================
// 函数: void SetMCLK(u8 clk)
// 描述: 设置主频
// 参数: clk: 主频序号
// 返回: none.
// 版本: VER1.0
// 日期: 2020-10-21
// 备注:
//========================================================================
void SetMCLK(u8 clk) //设置主频
{
if(clk > IRC_36M) return; //Error
CLK_ID = clk;
switch(clk)
{
case IRC_500K:
//选择500KHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T24M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 48;
MAIN_Fosc = 500000L; //定义主时钟
break;
case IRC_1M:
//选择1MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T24M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 24;
MAIN_Fosc = 1000000L; //定义主时钟
break;
case IRC_2M:
//选择2MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T24M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 12;
MAIN_Fosc = 2000000L; //定义主时钟
break;
case IRC_3M:
//选择3MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T24M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 8;
MAIN_Fosc = 3000000L; //定义主时钟
break;
case IRC_5M:
//选择5.5296MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T22M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 4;
MAIN_Fosc = 5529600L; //定义主时钟
break;
case IRC_6M:
//选择6MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T24M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 4;
MAIN_Fosc = 6000000L; //定义主时钟
break;
case IRC_8M:
//选择8MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T24M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 3;
MAIN_Fosc = 8000000L; //定义主时钟
break;
case IRC_10M:
//选择10MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T20M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 2;
MAIN_Fosc = 10000000L; //定义主时钟
break;
case IRC_11M:
//选择11.0592MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T22M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 2;
MAIN_Fosc = 11059200L; //定义主时钟
break;
case IRC_12M:
//选择12MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T24M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 2;
MAIN_Fosc = 12000000L; //定义主时钟
break;
case IRC_15M:
//选择15MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T30M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 2;
MAIN_Fosc = 15000000L; //定义主时钟
break;
case IRC_18M:
//选择18.432MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T36M_ROMADDR;
VRTRIM = VRT44M_ROMADDR;
IRCBAND = 0x03;
CLKDIV = 2;
MAIN_Fosc = 18432000L; //定义主时钟
break;
case IRC_20M:
//选择20MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T20M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 0;
MAIN_Fosc = 20000000L; //定义主时钟
break;
case IRC_24M:
//选择24MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T24M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 0;
MAIN_Fosc = 24000000L; //定义主时钟
break;
case IRC_27M:
//选择27MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T27M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 0;
MAIN_Fosc = 27000000L; //定义主时钟
break;
case IRC_30M:
//选择30MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T30M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 0;
MAIN_Fosc = 30000000L; //定义主时钟
break;
case IRC_33M:
//选择33.1176MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T33M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 0;
MAIN_Fosc = 33117600L; //定义主时钟
break;
case IRC_35M:
//选择35MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T35M_ROMADDR;
VRTRIM = VRT44M_ROMADDR;
IRCBAND = 0x03;
CLKDIV = 0;
MAIN_Fosc = 35000000L; //定义主时钟
break;
case IRC_36M:
//选择36.864MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T36M_ROMADDR;
VRTRIM = VRT44M_ROMADDR;
IRCBAND = 0x03;
CLKDIV = 0;
MAIN_Fosc = 36864000L; //定义主时钟
break;
default:
//选择22.1184MHz
//P_SW2 = 0x80;
CLKDIV = 0x04;
IRTRIM = T22M_ROMADDR;
VRTRIM = VRT27M_ROMADDR;
IRCBAND = 0x02;
CLKDIV = 0;
MAIN_Fosc = 22118400L; //定义主时钟
break;
}
Timer0_init(MAIN_Fosc/1000);
UART1_config(MAIN_Fosc, Baudrate); // brt: 通信波特率.
}
//========================================================================
// 函数: u8 GetCheckSum(u8 *buf, u8 len)
// 描述: 获取校验码
// 参数: buf: 字符串指针, len: 字节数
// 返回: none.
// 版本: VER1.0
// 日期: 2020-7-6
// 备注:
//========================================================================
u8 GetCheckSum(u8 *buf, u8 len) //获取校验码
{
u8 i;
u8 cs=0;
for (i = 0; i < len; i++)
{
cs += buf[i];
}
return cs;
}
//========================================================================
// 函数: void RX1_Check(void)
// 描述: 串口获取命令处理函数
// 参数: none.
// 返回: none.
// 版本: VER1.0
// 日期: 2020-7-6
// 备注:
//========================================================================
void RX1_Check(void)
{
u8 i;
u16 tmpValue;
if((RX1_Cnt >= 5) && (RX1_Buffer[CMD_SYNC1] == SYNC1) && (RX1_Buffer[CMD_SYNC2] == SYNC2)) //最短命令为10个字节
{
if(RX1_Buffer[CMD_TYPE] == 0x01) //上位机发送设置指令通信协议
{
if(RX1_Buffer[CMD_CS] == GetCheckSum(RX1_Buffer,CMD_CS))
{
P_SW2 |= 0x80; //允许访问XSF
IE2 &= 0x7F; //停止触摸中断
TSCTRL = 0; //停止自动扫描
TSSTA2 |= 0xc0; //清除标志位
TSRT = RX1_Buffer[CMD_TSRT]; //LED分时扫描
TSCHEN1 = RX1_Buffer[CMD_TSCHEN1]; //TK00~TK07
TSCHEN2 = RX1_Buffer[CMD_TSCHEN2]; //TK08~TK15
TSCFG1 = RX1_Buffer[CMD_TSCFG1]; //开关电容工作频率 = fosc/(2*(TSCFG1[6:4]+1)), 放电时间(系统时钟周期数) 0(125) 1(250) 2(500) 3(1000) 4(2000) 5(2500) 6(5000) 7(7500) 最小3
TSCFG2 = RX1_Buffer[CMD_TSCFG2]; //配置触摸按键控制器的内部参考电压(AVCC的分压比), 0(1/4) 1(1/2) 2(5/8) 3(3/4)
TSCTRL = RX1_Buffer[CMD_TSCTRL]; //开始自动扫描, 无平均, B7: TSGO, B6: SINGLE, B5: TSWAIT, B4: TSWUCS, B3: TSDCEN, B2: TSWUEN, B1 B0: TSSAMP
TSWUTC = RX1_Buffer[CMD_TSWUTC];
ScanFreq = ((u16)RX1_Buffer[CMD_SFREQ1] << 8) + RX1_Buffer[CMD_SFREQ2];
ChannelSet = ((u16)TSCHEN2 << 8) | TSCHEN1;
IE2 |= 0x80; //使能触摸中断
// P_SW2 &= ~0x80; //禁止访问xsf
for(i=0;i<16;i++)
{
tmpValue = (RX1_Buffer[CMD_TSTH00H+(i*2)] << 8) + RX1_Buffer[CMD_TSTH00L+(i*2)];
if(tmpValue > 200) //判断差值是否有效
{
TK_differ[i] = tmpValue >> 1; //阈值 = 差值/2
TK_lowest[i] = TK_differ[i] * 3;
}
}
read_cnt=0;
TK_TimeOut = 0;
B_Zero_Flag = 1; //重新获取0点
}
}
else if((RX1_Buffer[CMD_TYPE] == 0x02) && (RX1_Buffer[4] == GetCheckSum(RX1_Buffer,4)))
{
if(RX1_Buffer[3] < 16) //MCU回复触摸按键数据
{
SendBuffer[2] = 0x03;
SendBuffer[3] = RX1_Buffer[3];
SendBuffer[4] = (u8)(TK_cnt[RX1_Buffer[3]] >> 8);
SendBuffer[5] = (u8)TK_cnt[RX1_Buffer[3]];
SendBuffer[6] = (u8)(TK_zero[RX1_Buffer[3]] >> 8);
SendBuffer[7] = (u8)TK_zero[RX1_Buffer[3]];
SendBuffer[8] = GetCheckSum(SendBuffer,8);
for(i=0;i<9;i++)
{
UART1_TxByte(SendBuffer[i]);
}
}
else if(RX1_Buffer[3] == 0xfd) //MCU回复主频设置
{
SendBuffer[2] = 0x03;
SendBuffer[3] = RX1_Buffer[3];
SendBuffer[4] = CLK_ID;
SendBuffer[5] = GetCheckSum(SendBuffer,5);
for(i=0;i<6;i++)
{
UART1_TxByte(SendBuffer[i]);
}
}
else if(RX1_Buffer[3] == 0xfe) //MCU回复设置状态
{
P_SW2 |= 0x80; //允许访问XSF
SendBuffer[CMD_TYPE] = 0x04;
SendBuffer[CMD_TSCHEN1] = TSCHEN1;
SendBuffer[CMD_TSCHEN2] = TSCHEN2;
SendBuffer[CMD_TSCFG1] = TSCFG1;
SendBuffer[CMD_TSCFG2] = TSCFG2;
SendBuffer[CMD_TSCTRL] = TSCTRL;
SendBuffer[CMD_TSRT] = TSRT;
SendBuffer[CMD_SFREQ1] = (u8)(ScanFreq >> 8);
SendBuffer[CMD_SFREQ2] = (u8)ScanFreq;
SendBuffer[CMD_TSWUTC] = TSWUTC;
// P_SW2 &= ~0x80; //禁止访问xsf
for(i=0;i<16;i++)
{
tmpValue = TK_differ[i] << 1; //差值 = 阈值*2
SendBuffer[CMD_TSTH00H+(i*2)] = (u8)(tmpValue >> 8);
SendBuffer[CMD_TSTH00L+(i*2)] = (u8)tmpValue;
}
SendBuffer[CMD_CS] = GetCheckSum(SendBuffer,CMD_CS);
for(i=0;i<CMD_LEN;i++)
{
UART1_TxByte(SendBuffer[i]);
}
}
}
else if((RX1_Buffer[CMD_TYPE] == 0x05) && (RX1_Buffer[4] == GetCheckSum(RX1_Buffer,4))) //上位机发送设置主频指令
{
SetMCLK(RX1_Buffer[3]);
}
}
}
//========================================================================
// 函数: void TKSU_Interrupt(void)
// 描述: 触摸按键中断。
// 参数: none.
// 返回: none.
// 版本: VER1.0
// 日期: 2021-02-01
// 备注:
//========================================================================
void TKSU_Interrupt(void) interrupt 13
{
u8 j;
j = TSSTA2;
if(j & 0x40) //数据溢出, 错误处理(略)
{
TSSTA2 |= 0x40; //写1清零
}
if(j & 0x80) //扫描完成
{
j &= 0x0f;
TK_cnt[j] = TSDAT; //保存某个通道的读数
TSSTA2 |= 0x80; //写1清零
read_cnt++; //读次数+1, 用于延时或读键计数
TK_TimeOut = 0;
}
}