数码之家

 找回密码
 立即注册

QQ登录

只需一步,快速开始

微信登录

微信扫一扫,快速登录

搜索
查看: 1704|回复: 32

[C51] 老王USB电流电压表 充电容量统计 电流大小时间统计(开源)

  [复制链接]
发表于 2019-9-6 21:54:23 | 显示全部楼层 |阅读模式

马上注册,认识更多玩家好友,查阅更多资源,享有更多功能

您需要 登录 才可以下载或查看,没有帐号?立即注册 微信登录

x
今天闲下来了,有空写点东西。老王是谁?对,就是TB上“隔壁论坛老王电子数码”,卖的比较火热的一款“USB电压电流表”,功能除了没有快充诱导,其他主流功能该有的都有了,定价是个位数,太便宜了,还要啥自行车?(实在不推荐自己动手,因为太便宜)首先申明,盖房子的事是群内高人做的:该表的设计,硬件,打版,量产,都是群内高人做的,我这里没有PCB图。而我只负责房子的装修:软件编写。好了,话不多说,入正题:主控芯片: 芯圣HC89F0411 ,sop8 封装,有效IO 6个,出厂自带ISP可串口下载程序;

液晶屏:   一款老式手机的串口点阵屏,分辨率9664
电流放大:LM321 (新版是LM324?)
介绍下串口下载:需要用到usb转TTL板,按附图连接,我用的是CH341。注意,据说PL230x无法下载程序,原因未知。
程序烧写软件:HC-ISP V1.0.4   去芯圣官网下载

程序分为以下几个部分:
1   ST7565.h  ---显示程序
2   sys.h        ---系统设置
3   adc.h        ---ADC取样
4   flash.h      ---断电保存,数据存取
5   main.h      ---主程序:按键处理,定时器,看门狗

u表正面(借用图)

u表正面(借用图)

u表反面(借用图)

u表反面(借用图)

U表串口下载图

U表串口下载图

下载软件界面

下载软件界面

芯片描述

芯片描述

HC89f0411_v1.3_190219.rar

203.21 KB, 下载次数: 15, 下载积分: M币 -30

keilC51代码

USB电压电流表界面说明jam_HC89f0411_V1.3.pdf

321.88 KB, 下载次数: 27, 下载积分: M币 -30

用户操作说明书

打赏

参与人数 10M币 +266 收起 理由
baoshizhi + 20 就服你这样会写代码的大虾!
huaweiwx + 20 謝謝分享
411183343 + 20 熱心會員
q562379863 + 20 原創內容
jjyy1688 + 20 原創內容
温力口 + 16 谢谢分享。这帖子弄得我心痒痒的,看样子也.
飞向狙沙 + 20 謝謝分享
2545889167 + 20
wjxhone + 10 優秀文章
阿睦 + 100

查看全部打赏

 楼主| 发表于 2019-9-6 22:30:17 | 显示全部楼层

ST7565.h (显示程序)

本帖最后由 面条数码 于 2019-9-7 00:20 编辑

ST7565显示程序:(IIC 接口显示)
#ifndef __ST7565_H__
#define __ST7565_H__
#include <HC89F003.H>
#include  "sys.h"
#include <DELAY.H>
#include<intrins.h>
//========================================================================
//
// 描述: 本显示程序大部分来自QQ(USB电压电流表试产软件)群 ,感谢各位群友鼎力相助
// 参数:
// 返回:
// 版本: V1.0, 2019-1-9
//
//========================================================================
#define CH6x8   0
#define CH8x16  1
#define CH16x16 2
#define CH16x32 3

#define  printc_6x8(l,m,n)        printc(l,m,CH6x8,n)
#define  printc_8x16(l,m,n)        printc(l,m,CH8x16,n)
#define  printc_16x16(l,m,n)        printc(l,m,CH16x16,n)
#define  printc_16x32(l,m,n)        printc(l,m,CH16x32,n)


#define  printf_6x8(l,m,n)            printLCD(l,m,CH6x8,n)
#define  printf_8x16(l,m,n)            printLCD(l,m,CH8x16,n)
#define  printf_16x16(l,m,n)        printLCD(l,m,CH16x16,n)
#define  printf_16x32(l,m,n)        printLCD(l,m,CH16x32,n)



#ifdef         ZDQ

sbit SDA = P0 ^ 1;

#else

sbit SDA = P0 ^ 3;

#endif

sbit SCL = P0 ^ 4;
sbit I2CRST = P2 ^ 0;



/*
LCD 96 x 64 点阵屏
事实上,最上边一行还有一些图标,程序中不打算使用
如果要使用,位置是在 y=16
Row=17 col= 0 4 7 10 20 30 40 50 60 70 75 80 93 95 94
*/


#define uchar  unsigned char
#define uint   unsigned int



const uchar code LCD_INT[74] =
{
    0X78, 0X80, //选择地址,0X3C,加上W/R为0X78
    0X01, 0X80, //进0页
    0X09, 0X80, //选1页PS:选页指令在0页。
    0X06, 0X80, //选择正常显示模式
    0X12, 0X80, //选择偏置模式
    0X40, 0X80, //选择前8行的显示模式??
    0X01, 0X80, //回0页
    0X16, 0X80, //选择垂直模式,掉电模式
    0x20, 0x80, //选择Y地址,默认为0,可不设置。
    0X40, 0X80, //选择X地址,默认为0,可不设置.
    0X0C, 0X80, //翻到4页
    0X05, 0X80, //打开显示和直接驱动模式(电压倍增器)
    0X01, 0X80, //回0页
    0X0A, 0X80, //选2页
    0X08, 0X80, //设定2倍VLCD电压
    0X12, 0X80, //设定温度系数2
    0X04, 0X80, //设定VLCD为低,并关闭高压发生器
    0XC8, 0X80, //设定VLCD电压 ~=7.74V  //4.5+72*0.045
    0X01, 0X80, //回0页
    0X0B, 0X80, //翻到3页
    0X40, 0X80, //选择灰度0(寄存器)
    0X80, 0X80, //灰度0设为0
    0X41, 0X80, //选额灰度1
    0X94, 0X80, //灰度1设为20
    0X42, 0X80, //选择灰度2
    0XA8, 0X80, //灰度2设为40
    0X43, 0X80, //选择灰度3
    0XBF, 0X80, //灰度3设为63
    0X01, 0X80, //回0页
    0X0A, 0X80, //选择2页
    0X05, 0X80, //设定VLCD为低,并打开高压发生器
    0X01, 0X80, //回0页

// 0x12 设定垂直模式 ,交换MSB和LSB 0X12:不交换MSB和LSB
// 0x11 设定水平模式 ,交换MSB和LSB 0X12:不交换MSB和LSB
// 0x19 水平,交换高低位
// 0x1a 垂直,交换高低位
    0X1a, 0X80,
//      ^^^^显示方式

    0X0A, 0X80, //翻到2页
    0X09, 0X80, //设定VLCD为3X
    0X0A, 0X80, //设定VLCD为4X
    0X0B, 0X40, //设定VLCD为5x,X040:后面开始写DDRAM显示数据
};







//========================================================================
// 函数: delay()
// 描述: iic 延时用.
// 参数:
// 返回:
// 版本: V1.0, 2019-1-9
//========================================================================

void delay(void)
{
    _nop_();
    _nop_();
    _nop_();
    _nop_();
    _nop_();
    _nop_();

    _nop_();
    _nop_();
    _nop_();
    _nop_();
    _nop_();
}

//I2C init ----------------------------------------------------------------------

//========================================================================
// 函数: iics(void )
// 描述: I2C init.
// 参数:
// 返回:
// 版本: V1.0, 2019-1-9
//========================================================================
void iics(void )
{
    SDA = 1;
    delay();
    SCL = 1;
    delay();
    SDA = 0;
    delay();
    SCL =   0;
    SDA = 1;
}
//========================================================================
// 函数: iict(void )
// 描述: I2C init.
// 参数:
// 返回:
// 版本: V1.0, 2019-1-9
//========================================================================
void iict(void )
{
    SDA = 0;
    delay();
    SCL = 1;
    delay();
    SDA = 1;
    delay();
    SCL =   0;
    SDA = 1;
}


void write(uchar S_SND)
{
    uchar retry;
    uchar i, SOFT_ACK, SND;

    retry = 200;

    SOFT_ACK = 1;
    while (SOFT_ACK)
    {
        SND = S_SND;
        for (i = 8; i != 0; i--)
        {
            if (SND & 0X80)
                SDA = 1;
            else SDA = 0;
            SND <<= 1;
            delay();

            SCL = 1;
            delay();

            SCL = 0;
            delay();
        }
        SDA = 1;
        delay();
        SCL = 1;
        retry--;
        if ( (~SDA) || (retry == 0) )
        {
            delay();
            SOFT_ACK = 0;
        }
        SCL = 0;
    }
}



//LCD INT ------------------------------------------------------
//========================================================================
// 函数: LCD_INIT(void )
// 描述: LCD INT
// 参数:
// 返回:
// 版本: V1.0, 2019-1-9
//========================================================================
void LCD_INIT(void )
{
    uint num;
    I2CRST = 0;
    Delay_ms(15);
    I2CRST = 1;
    Delay_ms(15);

    iics();
    for (num = 0; num <= 74; num++)
    {
        write(LCD_INT[num]);

    }
}
//========================================================================
// 函数: LCD_cls(void)
// 描述: LCD CLS
// 参数:
// 返回:
// 版本: V1.0, 2019-1-9
//========================================================================

void LCD_cls(void)
{
    uint num;
    for (num = 0; num <= 1715; num++)
        write(0x00);
}

//========================================================================
// 函数: setxy(uchar x, uchar y)
// 描述: 定位位置
// 参数: uchar x :列位值 0-96
// 参数: uchar y :行位值 0-64
// 返回:
// 版本: V1.0, 2019-1-9
//========================================================================

void setxy(uchar x, uchar y)
{

    iict();
    delay();
    //  delay();
    iics();

    write(0X78);
    write(0X80);
    write(0X01);
    write(0X80);
    write(0X40 | y);
    write(0X80);
    write(0X80 | x);
    write(0X40);
}
/*
const uchar code F6x8[][6] =
{

    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   // sp
    { 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00 },   // !
    { 0x00, 0x00, 0x07, 0x00, 0x07, 0x00 },   // "
    { 0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14 },   // #
    { 0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12 },   // $
    { 0x00, 0x62, 0x64, 0x08, 0x13, 0x23 },   // %
    { 0x00, 0x36, 0x49, 0x55, 0x22, 0x50 },   // &
    { 0x00, 0x00, 0x05, 0x03, 0x00, 0x00 },   // '
    { 0x00, 0x00, 0x1c, 0x22, 0x41, 0x00 },   // (
    { 0x00, 0x00, 0x41, 0x22, 0x1c, 0x00 },   // )
    { 0x00, 0x14, 0x08, 0x3E, 0x08, 0x14 },   // *
    { 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08 },   // +
    { 0x00, 0x00, 0x00, 0xA0, 0x60, 0x00 },   // ,
    { 0x00, 0x08, 0x08, 0x08, 0x08, 0x08 },   // -

    { 0x00, 0x00, 0x60, 0x60, 0x00, 0x00 },   // .
    { 0x00, 0x20, 0x10, 0x08, 0x04, 0x02 },   // /
    { 0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E },   // 0
    { 0x00, 0x00, 0x42, 0x7F, 0x40, 0x00 },   // 1
    { 0x00, 0x42, 0x61, 0x51, 0x49, 0x46 },   // 2
    { 0x00, 0x21, 0x41, 0x45, 0x4B, 0x31 },   // 3
    { 0x00, 0x18, 0x14, 0x12, 0x7F, 0x10 },   // 4
    { 0x00, 0x27, 0x45, 0x45, 0x45, 0x39 },   // 5
    { 0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30 },   // 6
    { 0x00, 0x01, 0x71, 0x09, 0x05, 0x03 },   // 7
    { 0x00, 0x36, 0x49, 0x49, 0x49, 0x36 },   // 8
    { 0x00, 0x06, 0x49, 0x49, 0x29, 0x1E },   // 9
    { 0x00, 0x00, 0x36, 0x36, 0x00, 0x00 },   // :
    { 0x00, 0x00, 0x56, 0x36, 0x00, 0x00 },   // ;
    { 0x00, 0x08, 0x14, 0x22, 0x41, 0x00 },   // <
    { 0x00, 0x14, 0x14, 0x14, 0x14, 0x14 },   // =
    { 0x00, 0x00, 0x41, 0x22, 0x14, 0x08 },   // >
    { 0x00, 0x02, 0x01, 0x51, 0x09, 0x06 },   // ?
    { 0x00, 0x32, 0x49, 0x59, 0x51, 0x3E },   // @
    { 0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C },   // A
    { 0x00, 0x7F, 0x49, 0x49, 0x49, 0x36 },   // B
    { 0x00, 0x3E, 0x41, 0x41, 0x41, 0x22 },   // C
    { 0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C },   // D
    { 0x00, 0x7F, 0x49, 0x49, 0x49, 0x41 },   // E
    { 0x00, 0x7F, 0x09, 0x09, 0x09, 0x01 },   // F
    { 0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A },   // G
    { 0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F },   // H
    { 0x00, 0x00, 0x41, 0x7F, 0x41, 0x00 },   // I
    { 0x00, 0x20, 0x40, 0x41, 0x3F, 0x01 },   // J
    { 0x00, 0x7F, 0x08, 0x14, 0x22, 0x41 },   // K
    { 0x00, 0x7F, 0x40, 0x40, 0x40, 0x40 },   // L
    { 0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F },   // M
    { 0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F },   // N
    { 0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E },   // O
    { 0x00, 0x7F, 0x09, 0x09, 0x09, 0x06 },   // P
    { 0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E },   // Q
    { 0x00, 0x7F, 0x09, 0x19, 0x29, 0x46 },   // R
    { 0x00, 0x46, 0x49, 0x49, 0x49, 0x31 },   // S
    { 0x00, 0x01, 0x01, 0x7F, 0x01, 0x01 },   // T
    { 0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F },   // U
    { 0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F },   // V
    { 0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F },   // W
    { 0x00, 0x63, 0x14, 0x08, 0x14, 0x63 },   // X
    { 0x00, 0x07, 0x08, 0x70, 0x08, 0x07 },   // Y
    { 0x00, 0x61, 0x51, 0x49, 0x45, 0x43 },   // Z
    { 0x00, 0x00, 0x7F, 0x41, 0x41, 0x00 },   // [
    { 0x00, 0x55, 0x2A, 0x55, 0x2A, 0x55 },   // 55
    { 0x00, 0x00, 0x41, 0x41, 0x7F, 0x00 },   // ]
    { 0x00, 0x04, 0x02, 0x01, 0x02, 0x04 },   // ^
    { 0x00, 0x40, 0x40, 0x40, 0x40, 0x40 },   // _
    { 0x00, 0x00, 0x01, 0x02, 0x04, 0x00 },   // '
    { 0x00, 0x20, 0x54, 0x54, 0x54, 0x78 },   // a
    { 0x00, 0x7F, 0x48, 0x44, 0x44, 0x38 },   // b
    { 0x00, 0x38, 0x44, 0x44, 0x44, 0x20 },   // c
    { 0x00, 0x38, 0x44, 0x44, 0x48, 0x7F },   // d
    { 0x00, 0x38, 0x54, 0x54, 0x54, 0x18 },   // e
    { 0x00, 0x08, 0x7E, 0x09, 0x01, 0x02 },   // f
    { 0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C },   // g
    { 0x00, 0x7F, 0x08, 0x04, 0x04, 0x78 },   // h
    { 0x00, 0x00, 0x44, 0x7D, 0x40, 0x00 },   // i
    { 0x00, 0x40, 0x80, 0x84, 0x7D, 0x00 },   // j
    { 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00 },   // k

    { 0x00, 0x00, 0x41, 0x7F, 0x40, 0x00 },   // l

    { 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78 },   // m

    { 0x00, 0x7C, 0x08, 0x04, 0x04, 0x78 },   // n
    { 0x00, 0x38, 0x44, 0x44, 0x44, 0x38 },   // o
    { 0x00, 0xFC, 0x24, 0x24, 0x24, 0x18 },   // p
    { 0x00, 0x18, 0x24, 0x24, 0x18, 0xFC },   // q
    { 0x00, 0x7C, 0x08, 0x04, 0x04, 0x08 },   // r
    { 0x00, 0x48, 0x54, 0x54, 0x54, 0x20 },   // s
    { 0x00, 0x04, 0x3F, 0x44, 0x40, 0x20 },   // t
    { 0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C },   // u
    { 0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C },   // v
    { 0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C },   // w
    { 0x00, 0x44, 0x28, 0x10, 0x28, 0x44 },   // x
    { 0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C },   // y
    { 0x00, 0x44, 0x64, 0x54, 0x4C, 0x44 },   // z
    { 0x14, 0x14, 0x14, 0x14, 0x14, 0x14 },   // horiz lines
    {0x7E, 0x00, 0x00, 0x00, 0x00, 0x00},        //  "|"           //124     0x7C
    {0x7E, 0x7E, 0x00, 0x00, 0x00, 0x00},        //  "||"   //125         0x7D
    {0x7E, 0x7E, 0x7E, 0x00, 0x00, 0x00},        //  "|||"  //126         0x7E
    {0x7E, 0x7E, 0x7E, 0x7E, 0x00, 0x00},        //  "||||" //127         0x7F
    {0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x00},        //  "|||||"        //128    0x80
    {0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E}        //  "||||||" //129   0x81

};
*/
struct Cn6_8CharTypeDef                  // 汉字字模数据结构
{
    uchar  Index[1];            // 字母内码索引,
    uchar  Msk[6];             // 点阵码数据(16*16有32个数据)
};


const struct Cn6_8CharTypeDef code CN6_8CHAR[] =
{
    " ",
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00,    // sp
    ".",
    0x00, 0x00, 0x60, 0x60, 0x00, 0x00,    // .
    "0",
    0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E,    // 0
    "1",
    0x00, 0x00, 0x42, 0x7F, 0x40, 0x00,    // 1
    "2",
    0x00, 0x42, 0x61, 0x51, 0x49, 0x46,    // 2
    "3",
    0x00, 0x21, 0x41, 0x45, 0x4B, 0x31,    // 3
    "4",
    0x00, 0x18, 0x14, 0x12, 0x7F, 0x10,    // 4
    "5",
    0x00, 0x27, 0x45, 0x45, 0x45, 0x39,    // 5
    "6",
    0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30,    // 6
    "7",
    0x00, 0x01, 0x71, 0x09, 0x05, 0x03,    // 7
    "8",
    0x00, 0x36, 0x49, 0x49, 0x49, 0x36,    // 8
    "9",
    0x00, 0x06, 0x49, 0x49, 0x29, 0x1E,    // 9
    "A",
    0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C,    // A
    "m",
    0x00, 0x7C, 0x04, 0x18, 0x04, 0x78,    // m
    "h",
    0x00, 0x7F, 0x08, 0x04, 0x04, 0x78,    // h
    "k",
    0x00, 0x7F, 0x10, 0x28, 0x44, 0x00,    // k


    "C",                           //16         =0x10
    0x7E, 0x00, 0x00, 0x00, 0x00, 0x00,        //  "|"           //16     0x10
    "D",
    0x7E, 0x7E, 0x00, 0x00, 0x00, 0x00,        //  "||"   //17         0x11
    "E",
    0x7E, 0x7E, 0x7E, 0x00, 0x00, 0x00,        //  "|||"  //18         0x12
    "F",
    0x7E, 0x7E, 0x7E, 0x7E, 0x00, 0x00,        //  "||||" //19         0x13
    "G",
    0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x00,        //  "|||||"        //20    0x14
    "H",
    0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E        //  "||||||" //21   0x15


};






struct Cn8_16CharTypeDef                  // 汉字字模数据结构
{
    uchar  Index[1];            // 字母内码索引,
    uchar  Msk[16];             // 点阵码数据(16*16有32个数据)
};

const struct Cn8_16CharTypeDef code CN8_16CHAR[] =
{
    " ",
    {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 //  0
    },

    ".",
    {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00 //. 1
    },

    "0",
    {
        0x00, 0xE0, 0x10, 0x08, 0x08, 0x10, 0xE0, 0x00, 0x00, 0x0F, 0x10, 0x20, 0x20, 0x10, 0x0F, 0x00//0 2
    },
    "1",
    {
        0x00, 0x10, 0x10, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x3F, 0x20, 0x20, 0x00, 0x00 //1 3
    },
    "2",
    {
        0x00, 0x70, 0x08, 0x08, 0x08, 0x88, 0x70, 0x00, 0x00, 0x30, 0x28, 0x24, 0x22, 0x21, 0x30, 0x00 //2 4
    },
    "3",
    {
        0x00, 0x30, 0x08, 0x88, 0x88, 0x48, 0x30, 0x00, 0x00, 0x18, 0x20, 0x20, 0x20, 0x11, 0x0E, 0x00 //3 5
    },
    "4",
    {
        0x00, 0x00, 0xC0, 0x20, 0x10, 0xF8, 0x00, 0x00, 0x00, 0x07, 0x04, 0x24, 0x24, 0x3F, 0x24, 0x00 //4 6
    },
    "5",
    {
        0x00, 0xF8, 0x08, 0x88, 0x88, 0x08, 0x08, 0x00, 0x00, 0x19, 0x21, 0x20, 0x20, 0x11, 0x0E, 0x00 //5 7
    },
    "6",
    {
        0x00, 0xE0, 0x10, 0x88, 0x88, 0x18, 0x00, 0x00, 0x00, 0x0F, 0x11, 0x20, 0x20, 0x11, 0x0E, 0x00//6 8
    },
    "7",
    {
        0x00, 0x38, 0x08, 0x08, 0xC8, 0x38, 0x08, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00 //7 9
    },
    "8",
    {
        0x00, 0x70, 0x88, 0x08, 0x08, 0x88, 0x70, 0x00, 0x00, 0x1C, 0x22, 0x21, 0x21, 0x22, 0x1C, 0x00 //8 10
    },
    "9",
    {
        0x00, 0xE0, 0x10, 0x08, 0x08, 0x10, 0xE0, 0x00, 0x00, 0x00, 0x31, 0x22, 0x22, 0x11, 0x0F, 0x00  //9 11
    },
    "V",  //12
    {
        0x08, 0x78, 0x88, 0x00, 0x00, 0xC8, 0x38, 0x08, 0x00, 0x00, 0x07, 0x38, 0x0E, 0x01, 0x00, 0x00  //V 12
    },
    "A",  //13
    {
        0x00, 0x00, 0xC0, 0x38, 0xE0, 0x00, 0x00, 0x00, 0x20, 0x3C, 0x23, 0x02, 0x02, 0x27, 0x38, 0x20  //A 13
    },
    ":",  //14
    {
        0x00, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00  //: 14
    },
    "m",  //15
    {
        0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x20, 0x3F, 0x20, 0x00, 0x3F, 0x20, 0x00, 0x3F  //m
    },
    "h",  //16
    {
        0x08, 0xF8, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x20, 0x3F, 0x21, 0x00, 0x00, 0x20, 0x3F, 0x20  //"h"
    },

    "+",  //17
    {
        0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x1F, 0x01, 0x01, 0x01, 0x00  //"+"
    },
    "-",  //18
    {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01  //"-"
    },
    "%",  //19
    {
        0x00, 0x38, 0x28, 0x38, 0xE0, 0x30, 0x0C, 0x02, 0x20, 0x18, 0x0E, 0x03, 0x0E, 0x7A, 0x5E, 0x70  //"%%千分号"//  19
    },

    "a",    //20    //mAh
    {
        0xFF, 0xE1, 0x7D, 0xA1, 0xA1, 0x7D, 0xE1, 0xFF, 0xFF, 0xF8, 0x05, 0xDD, 0xDD, 0x1D, 0xF8, 0xFF  //"mAh"///  21
    },
    //   "a",//21    //mAh
    //     0x00,0xCF,0xA1,0x91,0x9F,0xA1,0xC1,0x0F,0x00,0x03,0xFC,0x10, 0x10,0xF0,0x03,0x00, //"mAh"///  21


//   "w",  //22  //mWh
//   0x00,0x6F,0xC1,0x81,0xEF,0x81,0xC1,0x6F,0x00,0x00,0xFF,0x13, 0x10,0xF3,0x03,0x00,
//   "w", //22  //mWh
//   0xFF, 0x21, 0xFD, 0x21, 0x21, 0xFD, 0x21, 0xFF, 0xFF, 0xFF, 0x04, 0xDE, 0xDE, 0x1C, 0xFF, 0xFF ///"mWh"/// 22


    "w", //21  //mWh
    {
        0xFF, 0x21, 0xFD, 0x61, 0x61, 0xFD, 0x21, 0xFF, 0xFF, 0xFC, 0x03, 0xD8, 0xD8, 0x1B, 0xFC, 0xFF //w//   23
    },

    "W", //22  //wh
    {
        0xFF, 0xC1, 0xBF, 0x83, 0x83, 0xBF, 0xC1, 0xFF, 0xFF, 0xFF, 0x00, 0xF7, 0xF7, 0x07, 0xFF, 0xFF //wh//   23
    },

    "H", //23   //Ah
    {
        0xFF, 0x87, 0xEB, 0xED, 0xED, 0xEB, 0x87, 0xFF, 0xFF, 0xFF, 0x00, 0xF7, 0xF7, 0x07, 0xFF, 0xFF //Ah     24
    },

    "p", //24   //mW  毫瓦
    {
        0xFF, 0x81, 0xFD, 0x81, 0x81, 0xFD, 0x81, 0xFF, 0xFF, 0xE1, 0xDF, 0x83, 0x83, 0xDF, 0xE1, 0xFF //mW//power
    },

//  "P", //25   //W 瓦特
//  0xF8,0x08,0x00,0xF8,0x00,0x08,0xF8,0x00,0x03,0x3C,0x07,0x00,0x07,0x3C,0x03,0x00 ,//"W",0//


    "O", //25   //欧姆
    {
        0xFF, 0x1F, 0xDF, 0xDF, 0xDF, 0xDF, 0x1F, 0xFF, 0x7F, 0xEE, 0xE1, 0xFF, 0xFF, 0xE1, 0xEE, 0x7F //欧姆
    },
    "C", ////26上次
    {
        0x00, 0x40, 0x40, 0x7E, 0x48, 0x48, 0x40, 0x00, 0x00, 0x24, 0x54, 0x23, 0x1E, 0x22, 0x46, 0x00 // 上次
    },

    "<", //27
    {
        0x00, 0x00, 0x80, 0x40, 0x20, 0x10, 0x08, 0x00, 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x00 //"<",0//
    },

    ">", //28
    {
        0x00, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00 //">",1//
    },
    "s", //29
    {
        0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x33, 0x24, 0x24, 0x24, 0x24, 0x19, 0x00 //"s",0//
    },

    "/", //30
    {
        0x00, 0x00, 0x00, 0x00, 0xC0, 0x38, 0x04, 0x00, 0x00, 0x60, 0x18, 0x07, 0x00, 0x00, 0x00, 0x00 //"/",1//
    }
};


struct Cn16_16CharTypeDef                  // 汉字字模数据结构
{
    uchar  Index[2];            // 字母内码索引,
    uchar  Msk[32];             // 点阵码数据(16*16有32个数据)
};

//列行式,逆向
const struct Cn16_16CharTypeDef code CN16_16CHAR[] =
{
    "电",     //0
    {
        0x00, 0x00, 0xF0, 0x90, 0x90, 0x90, 0x90, 0xFC, 0x90, 0x90, 0x90, 0x90, 0x90, 0xF0, 0x00, 0x00,
        0x00, 0x00, 0x0F, 0x04, 0x04, 0x04, 0x04, 0x7F, 0x44, 0x44, 0x44, 0x44, 0x44, 0x4F, 0x30, 0x00
    },

    "压",   //1
    {
        0x00, 0x00, 0xF8, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0xF8, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00,
        0x40, 0x70, 0x0F, 0x00, 0x20, 0x21, 0x21, 0x21, 0x21, 0x3F, 0x21, 0x25, 0x2D, 0x39, 0x20, 0x20
    },

    "流",   //2
    {
        0x00, 0x40, 0x44, 0x88, 0x90, 0x90, 0x90, 0xD0, 0xB0, 0x9C, 0x98, 0xB0, 0xD0, 0x90, 0x10, 0x00,
        0x00, 0x40, 0x30, 0x0C, 0x44, 0x40, 0x20, 0x1E, 0x00, 0x7E, 0x00, 0x00, 0x7E, 0x40, 0x41, 0x20
    },



    "校",   //3
    {
        0x00, 0x20, 0x20, 0xA0, 0xFC, 0x20, 0x20, 0x90, 0xF0, 0x54, 0x14, 0x18, 0x10, 0x50, 0x90, 0x10,
        0x00, 0x00, 0x06, 0x01, 0x7F, 0x41, 0x43, 0x41, 0x23, 0x24, 0x18, 0x18, 0x27, 0x20, 0x40, 0x40
    },

    "准",  //4
    {
        0x00, 0x08, 0x18, 0x30, 0x00, 0xC0, 0x60, 0xF0, 0xAE, 0xA4, 0xA4, 0xEC, 0xA8, 0xA0, 0xA0, 0x00,
        0x00, 0x10, 0x18, 0x04, 0x02, 0x00, 0x00, 0x7F, 0x24, 0x24, 0x24, 0x3F, 0x24, 0x24, 0x24, 0x20
    },


    "退",  //5
    {
        0x00, 0x80, 0x88, 0xD8, 0xB0, 0x00, 0x00, 0xF8, 0xA8, 0xA8, 0xA8, 0xA8, 0xF8, 0x08, 0x00, 0x00,
        0x00, 0x60, 0x20, 0x1F, 0x20, 0x20, 0x50, 0x7F, 0x52, 0x4A, 0x44, 0x44, 0x4B, 0x59, 0x20, 0x00
    },


    "出",  //6
    {
        0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00,
        0x00, 0x20, 0x7E, 0x23, 0x21, 0x21, 0x21, 0x3F, 0x21, 0x21, 0x21, 0x21, 0x23, 0x7E, 0x00, 0x00
    },



    "分",   //7
    {
        0x00, 0x00, 0x00, 0x80, 0x60, 0x30, 0x18, 0x00, 0x00, 0x0C, 0x30, 0xC0, 0x80, 0x80, 0x00, 0x00,
        0x00, 0x02, 0x41, 0x40, 0x21, 0x19, 0x07, 0x21, 0x21, 0x41, 0x61, 0x3F, 0x01, 0x01, 0x01, 0x00
    },

    "XN",   //8                 随便改成什么都能出,改成"星",居然不出字。
    {
        0x00, 0x00, 0x00, 0xF8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xF8, 0x00, 0x00, 0x00,
        0x10, 0x28, 0x2C, 0x2F, 0x2B, 0x2A, 0x2A, 0x3F, 0x2A, 0x2A, 0x2A, 0x2F, 0x3B, 0x32, 0x20, 0x00
    },//"星",0//


    "期",   //9
    {
        0x00, 0x20, 0x20, 0xF8, 0xA0, 0xA0, 0xF8, 0x20, 0x20, 0x20, 0xF0, 0x90, 0x90, 0x98, 0xF8, 0x00,
        0x00, 0x44, 0x24, 0x1F, 0x05, 0x0D, 0x17, 0x34, 0x44, 0x38, 0x0F, 0x02, 0x22, 0x42, 0x7F, 0x00
    }//"期",1//
    /*
      "QQ",   //8
      {
          0xAF, 0xA9, 0xED, 0x0F, 0xA0, 0xAF, 0xE9, 0x0D, 0xEF, 0x80, 0xEA, 0x00, 0x27, 0x24, 0xEF, 0x00,
          0xFB, 0x8A, 0xFA, 0x00, 0x3B, 0x22, 0xFA, 0x00, 0xB8, 0xA8, 0xEB, 0x00, 0xB8, 0xA8, 0xFB, 0x00 //QQ:422470459/
      },
    */
} ;



struct Cn16_32CharTypeDef                  // 汉字字模数据结构
{
    uchar  Index[1];            // 字母内码索引,
    uchar  Msk[64];             // 点阵码数据(16*16有32个数据)
};

const struct Cn16_32CharTypeDef code CN16_32CHAR[] =
{

    ":",
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xE0, 0xE0, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //":",0//

    "0",
    0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x80, 0x00, 0x00, 0x00,
    0x00, 0xF0, 0xFE, 0xFF, 0xFF, 0x07, 0x01, 0x00, 0x00, 0x00, 0x03, 0x0F, 0xFF, 0xFF, 0xFC, 0x00,
    0x00, 0x1F, 0xFF, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x7F, 0x00,
    0x00, 0x00, 0x00, 0x03, 0x03, 0x07, 0x07, 0x0E, 0x0E, 0x0E, 0x07, 0x07, 0x03, 0x01, 0x00, 0x00, //"0",1//

    "1",
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x1C, 0x1C, 0x0E, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, //"1",2//

    "2",
    0x00, 0x00, 0x00, 0x80, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x80, 0x80, 0x00, 0x00,
    0x00, 0x04, 0x07, 0x07, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0xC1, 0xFF, 0xFF, 0xFF, 0x1E, 0x00,
    0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0x78, 0x3E, 0x1F, 0x0F, 0x03, 0x01, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x00, //"2",3//

    "3",
    0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x80, 0x80, 0x00, 0x00,
    0x00, 0x00, 0x06, 0x0F, 0x0F, 0x03, 0x81, 0x80, 0x80, 0xC0, 0xC1, 0xFF, 0x7F, 0x7F, 0x1E, 0x00,
    0x00, 0x40, 0xC0, 0xE0, 0xE0, 0x80, 0x01, 0x01, 0x01, 0x03, 0x03, 0xDF, 0xFF, 0xFE, 0xFC, 0x00,
    0x00, 0x00, 0x01, 0x03, 0x07, 0x07, 0x07, 0x0E, 0x0E, 0x0E, 0x07, 0x07, 0x03, 0x03, 0x00, 0x00, //"3",4//

    "4",
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xC0, 0xC0, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0x7C, 0x3E, 0x1F, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,
    0x70, 0x78, 0x7E, 0x7F, 0x7F, 0x73, 0x71, 0x70, 0x70, 0x70, 0xFF, 0xFF, 0xFF, 0x70, 0x70, 0x70,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, //"4",5//

    "5",
    0x00, 0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x00, 0x00,
    0x00, 0x80, 0xF8, 0xFF, 0xFF, 0xEF, 0x60, 0x60, 0x60, 0xE0, 0xE0, 0xC0, 0xC0, 0x80, 0x00, 0x00,
    0x00, 0xC1, 0xE1, 0xE1, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xE7, 0xFF, 0xFF, 0xFE, 0x00,
    0x00, 0x01, 0x03, 0x07, 0x07, 0x0E, 0x0E, 0x0E, 0x0E, 0x0F, 0x07, 0x07, 0x03, 0x01, 0x00, 0x00, //"5",6//

    "6",
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0xC0, 0xF0, 0xF8, 0xFE, 0xFF, 0xCF, 0xC7, 0xC1, 0xC0, 0xC0, 0x80, 0x00, 0x00,
    0x00, 0x7C, 0xFF, 0xFF, 0xFF, 0x83, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFE,
    0x00, 0x00, 0x01, 0x03, 0x07, 0x07, 0x07, 0x0E, 0x0E, 0x0E, 0x0E, 0x07, 0x07, 0x03, 0x01, 0x00, //"6",7//

    "7",
    0x00, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xE0, 0xF8, 0xFE, 0x3F, 0x0F, 0x03, 0x01,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xF0, 0xFE, 0xFF, 0x3F, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x04, 0x07, 0x07, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //"7",8//

    "8",
    0x00, 0x00, 0x00, 0x80, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x80, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x7F, 0x7F, 0xFF, 0xE1, 0xC0, 0x80, 0x80, 0xC0, 0xE1, 0xFF, 0x7F, 0x7F, 0x1E, 0x00,
    0x00, 0xFC, 0xFE, 0xFF, 0xCF, 0x07, 0x03, 0x01, 0x01, 0x03, 0x03, 0x8F, 0xFF, 0xFE, 0xFC, 0x00,
    0x00, 0x01, 0x03, 0x07, 0x07, 0x07, 0x0E, 0x0E, 0x0E, 0x0E, 0x07, 0x07, 0x07, 0x03, 0x01, 0x00, //"8",9//

    "9",
    0x00, 0x00, 0x00, 0x80, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x80, 0x00, 0x00, 0x00,
    0x00, 0xFE, 0xFF, 0xFF, 0x87, 0x01, 0x01, 0x00, 0x00, 0x01, 0x83, 0xFF, 0xFF, 0xFF, 0x7E, 0x00,
    0x00, 0x01, 0x03, 0x07, 0x07, 0x07, 0x86, 0xE6, 0xFE, 0xFF, 0x7F, 0x1F, 0x07, 0x03, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x08, 0x0E, 0x0F, 0x0F, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 //"9",10//

};




void printc(uchar x, unsigned y, uchar charmode, uchar c)
{

    uchar cn, ki, kl, kn;


    uchar k, ky;
    uchar i;    //用于循环
    uchar temp; //编码转换

    y = 15 - y;


    k = 0;
    ky = 2;

    if (charmode == CH6x8)
    {
        ki = 6;
        kl = 6;
        kn = 6;
        ky = 0;

    }

    else if (charmode == CH8x16)
    {
        ki = 8;
        kl = 8;
        kn = 16;


    }
    else  if  (charmode == CH16x16)
    {
        ki = 16;
        kl = 16;
        kn = 32;


    }
    else  if  (charmode == CH16x32)
    {
        ki = 16;
        kl = 16;
        kn = 64;

    }


    do
    {
        for (i = 0; i < ki; i++)
        {

            if  (charmode == CH6x8)
            {
                cn = CN6_8CHAR[c].Msk[i + k];

            }

            else if  (charmode == CH8x16)
            {
                cn = CN8_16CHAR[c].Msk[i + k];

            }
            else  if  (charmode == CH16x16)
            {
                cn = CN16_16CHAR[c].Msk[i + k];

            }
            else  if  (charmode == CH16x32)
            {
                cn = CN16_32CHAR[c].Msk[i + k];

            }

            setxy(x + i, y + ky);
            temp = 0;
            if (cn & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
            if (cn & 0x40) temp += 0x30; //11最深,01淡,10最淡
            if (cn & 0x20) temp += 0x0c;
            if (cn & 0x10) temp += 0x03;
            write(temp);
            temp = 0;
            if (cn & 0x08) temp += 0xc0;
            if (cn & 0x04) temp += 0x30;
            if (cn & 0x02) temp += 0x0c;
            if (cn & 0x01) temp += 0x03;
            write(temp);
        }



        if (ky == 0  )
        {
            ky = 9 ;                        //为什么是9?
            y = 15 - y ;
        }

        ky -= 2;

        k += kl;


    } while (k < kn);




}

//========================================================================
// 函数: printc_6x8(uchar x, uchar y, uchar c)
// 描述: 字符打印
// 参数: uchar x :列位值 0-88
// 参数: uchar y :行位值 0-15
// 参数: uchar c :字符数列位置,打印数字需要 + 0x30
// 返回:
// 版本: V1.0, 2019-1-9
//========================================================================
/*
void printc_6x8(uchar x, uchar y, uchar c)
{

uchar cn;
   uchar i;    //用于循环
   uchar temp; //编码转换
   c -= ' ';
   y = 15 - y;



         setxy(x + i, y);
          temp = 0;
          if (F6x8[c] & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
          if (F6x8[c] & 0x40) temp += 0x30; //11最深,01淡,10最淡
          if (F6x8[c] & 0x20) temp += 0x0c;
          if (F6x8[c] & 0x10) temp += 0x03;
          write(temp);
          temp = 0;
          if (F6x8[c] & 0x08) temp += 0xc0;
          if (F6x8[c] & 0x04) temp += 0x30;
          if (F6x8[c] & 0x02) temp += 0x0c;
          if (F6x8[c] & 0x01) temp += 0x03;
          write(temp);
      }



}

*/



void printLCD(uchar x, uchar y, uchar charmode, uchar *s)
{
    uchar  kl, ky;
    uchar cn;
    uchar l = 0, wordNum;

    if (charmode == CH6x8)
    {

        kl = 6;
        ky = 2;

    }

    else if (charmode == CH8x16)
    {
        kl = 8;
        ky = 4;


    }
    else  if  (charmode == CH16x16)
    {
        kl = 16;
        ky = 4;


    }
    else  if  (charmode == CH16x32)
    {
        kl = 16;
        ky = 8;

    }



    while (*s != '\0')
    {
        for (wordNum = 0; wordNum < 50; wordNum++)         //从50个数组中查找
        {

            if  (charmode == CH6x8)
            {
                cn = CN6_8CHAR[wordNum].Index[0];

            }

            else if  (charmode == CH8x16)
            {
                cn = CN8_16CHAR[wordNum].Index[0];

            }
            else  if  (charmode == CH16x16)
            {
                cn = CN16_16CHAR[wordNum].Index[0];

            }
            else  if  (charmode == CH16x32)
            {
                cn = CN16_32CHAR[wordNum].Index[0];

            }




            if (cn == *s)
            {

                if (charmode == CH16x16 )           //比较两个字节
                {
                    if (CN16_16CHAR[wordNum].Index[1] == *(s + 1))   printc(x + l, y, CH16x16, wordNum);

                }
                else
                {

                    printc(x + l, y, charmode, wordNum);

                }

                //s++;
                l += kl;
                if ((x + l) > 90) //自动换行
                {
                    y += ky;
                    l = 0;
                    x = 0;
                }

                break; //跳出循环
            }



        }
        s++;
         if (charmode == CH16x16 )           //比较两个字节
        {s++; }
    }




}


//========================================================================
// 函数: printf_6x8(uchar x, uchar y, uchar c)
// 描述: 字符串打印程序
// 参数: uchar x :列位值 0-88
// 参数: uchar y :行位值 0-15
// 参数: uchar c :字符数列位置,打印数字需要 + 0x30
// 返回:
// 版本: V1.0, 2019-1-9
//========================================================================
/*
void printf_6x8(uchar x, uchar y, uchar *s)
{

      uchar l = 0;
      while (*s)
      {
          printc_6x8(x + l, y, *s);
          s++;
          l += 6;
          if ((x + l) > 90) //自动换行
          {
              y += 2;
              l = 0;
              x = 0;
          }
      }





    uchar l = 0, wordNum;
    while (*s != '\0')
    {
        for (wordNum = 0; wordNum < 50; wordNum++)         //从50个数组中查找
        {
            if (CN6_8CHAR[wordNum].Index[0] == *s)
            {
                printc_6x8(x + l, y, wordNum);
                //s++;
                l += 6;
                if ((x + l) > 90) //自动换行
                {
                    y += 2;
                    l = 0;
                    x = 0;
                }

                break; //跳出循环
            }

        }
        s++;
    }




}

*/




/*
void print_8x16(uchar x, unsigned y, const uchar * p)
{
    uchar i;    //用于循环
    uchar temp; //编码转换

    y = 15 - y;
// c++;
    for (i = 0; i < 8; i++)                   //8x8
    {
        setxy(x + i, y + 2);
        temp = 0;
        if ((*p+i) & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
        if ((*p+i) & 0x40) temp += 0x30; //11最深,01淡,10最淡
        if ((*p+i) & 0x20) temp += 0x0c;
        if ((*p+i) & 0x10) temp += 0x03;
        write(temp);
        temp = 0;
        if ((*p+i) & 0x08) temp += 0xc0;
        if ((*p+i) & 0x04) temp += 0x30;
        if ((*p+i) & 0x02) temp += 0x0c;
        if ((*p+i) & 0x01) temp += 0x03;
        write(temp);
    }
    for (i = 0; i < 8; i++)           //上半部8x8
    {
        setxy(x + i, y);
        temp = 0;
        if ((*p+i+8) & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
        if ((*p+i+8) & 0x40) temp += 0x30; //11最深,01淡,10最淡
        if ((*p+i+8) & 0x20) temp += 0x0c;
        if ((*p+i+8) & 0x10) temp += 0x03;
        write(temp);
        temp = 0;
        if ((*p+i+8) & 0x08) temp += 0xc0;
        if ((*p+i+8) & 0x04) temp += 0x30;
        if ((*p+i+8) & 0x02) temp += 0x0c;
        if ((*p+i+8) & 0x01) temp += 0x03;
        write(temp);
    }
}

*/



/*
void printc_8x16(uchar x, unsigned y, uchar c)
{

printc( x, y, CH8x16,  c)        ;


//   uchar k, ky;
    uchar i;    //用于循环
    uchar temp; //编码转换

    y = 15 - y;
*/
/*
for (i = 0; i < 8; i++)                   //8x8
{
    setxy(x + i, y + 2);
    temp = 0;
    if (CN8_16CHAR[c].Msk & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
    if (CN8_16CHAR[c].Msk & 0x40) temp += 0x30; //11最深,01淡,10最淡
    if (CN8_16CHAR[c].Msk & 0x20) temp += 0x0c;
    if (CN8_16CHAR[c].Msk & 0x10) temp += 0x03;
    write(temp);
    temp = 0;
    if (CN8_16CHAR[c].Msk & 0x08) temp += 0xc0;
    if (CN8_16CHAR[c].Msk & 0x04) temp += 0x30;
    if (CN8_16CHAR[c].Msk & 0x02) temp += 0x0c;
    if (CN8_16CHAR[c].Msk & 0x01) temp += 0x03;
    write(temp);
}


for (i = 0; i < 8; i++)           //上半部8x8
{
    setxy(x + i, y);
    temp = 0;
    if (CN8_16CHAR[c].Msk[i + 8] & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
    if (CN8_16CHAR[c].Msk[i + 8] & 0x40) temp += 0x30; //11最深,01淡,10最淡
    if (CN8_16CHAR[c].Msk[i + 8] & 0x20) temp += 0x0c;
    if (CN8_16CHAR[c].Msk[i + 8] & 0x10) temp += 0x03;
    write(temp);
    temp = 0;
    if (CN8_16CHAR[c].Msk[i + 8] & 0x08) temp += 0xc0;
    if (CN8_16CHAR[c].Msk[i + 8] & 0x04) temp += 0x30;
    if (CN8_16CHAR[c].Msk[i + 8] & 0x02) temp += 0x0c;
    if (CN8_16CHAR[c].Msk[i + 8] & 0x01) temp += 0x03;
    write(temp);
}

*/



/*
k = 0;
ky = 2;



do
{
     for (i = 0; i < 8; i++)                   //8x8
     {
         setxy(x + i, y + ky);
         temp = 0;
         if (CN8_16CHAR[c].Msk[i + k] & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
         if (CN8_16CHAR[c].Msk[i + k] & 0x40) temp += 0x30; //11最深,01淡,10最淡
         if (CN8_16CHAR[c].Msk[i + k] & 0x20) temp += 0x0c;
         if (CN8_16CHAR[c].Msk[i + k] & 0x10) temp += 0x03;
         write(temp);
         temp = 0;
         if (CN8_16CHAR[c].Msk[i + k] & 0x08) temp += 0xc0;
         if (CN8_16CHAR[c].Msk[i + k] & 0x04) temp += 0x30;
         if (CN8_16CHAR[c].Msk[i + k] & 0x02) temp += 0x0c;
         if (CN8_16CHAR[c].Msk[i + k] & 0x01) temp += 0x03;
         write(temp);
     }
     ky -= 2;
     k += 8;

} while (k < 16);






}


*/

/*
void printf_8x16(uchar x, uchar y, uchar *s)
{
   uchar l = 0, wordNum;
   while (*s != '\0')
   {
       for (wordNum = 0; wordNum < 50; wordNum++)         //从50个数组中查找
       {
           if (CN8_16CHAR[wordNum].Index[0] == *s)
           {
               printc_8x16(x + l, y, wordNum);
               //s++;
               l += 8;
               if ((x + l) > 90) //自动换行
               {
                   y += 4;
                   l = 0;
                   x = 0;
               }

               break; //跳出循环
           }

       }
       s++;
   }
}
*/










/*
void printc_16x16(uchar x, unsigned y, unsigned c)
{
   printc( x, y, CH16x16,  c)        ;

       uchar k, ky;

       uchar i;    //用于循环
       uchar temp; //编码转换

       y = 15 - y;







/*
   for (i = 0; i < 16; i++)                           //8x16
   {
       setxy(x + i, y + 2);
       temp = 0;
       if (CN16_16CHAR[c].Msk & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
       if (CN16_16CHAR[c].Msk & 0x40) temp += 0x30; //11最深,01淡,10最淡
       if (CN16_16CHAR[c].Msk & 0x20) temp += 0x0c;
       if (CN16_16CHAR[c].Msk & 0x10) temp += 0x03;
       write(temp);
       temp = 0;
       if (CN16_16CHAR[c].Msk & 0x08) temp += 0xc0;
       if (CN16_16CHAR[c].Msk & 0x04) temp += 0x30;
       if (CN16_16CHAR[c].Msk & 0x02) temp += 0x0c;
       if (CN16_16CHAR[c].Msk & 0x01) temp += 0x03;
       write(temp);
   }
   for (i = 0; i < 16; i++)                                //上半部8x16
   {
       setxy(x + i, y);
       temp = 0;
       if (CN16_16CHAR[c].Msk[i + 16] & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
       if (CN16_16CHAR[c].Msk[i + 16] & 0x40) temp += 0x30; //11最深,01淡,10最淡
       if (CN16_16CHAR[c].Msk[i + 16] & 0x20) temp += 0x0c;
       if (CN16_16CHAR[c].Msk[i + 16] & 0x10) temp += 0x03;
       write(temp);
       temp = 0;
       if (CN16_16CHAR[c].Msk[i + 16] & 0x08) temp += 0xc0;
       if (CN16_16CHAR[c].Msk[i + 16] & 0x04) temp += 0x30;
       if (CN16_16CHAR[c].Msk[i + 16] & 0x02) temp += 0x0c;
       if (CN16_16CHAR[c].Msk[i + 16] & 0x01) temp += 0x03;
       write(temp);
   }

  */




/*
k = 0;
ky = 2;

do
{

  for (i = 0; i < 16; i++)                   //8x8
  {
      setxy(x + i, y + ky );
      temp = 0;
      if (CN16_16CHAR[c].Msk[i + k] & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
      if (CN16_16CHAR[c].Msk[i + k] & 0x40) temp += 0x30; //11最深,01淡,10最淡
      if (CN16_16CHAR[c].Msk[i + k] & 0x20) temp += 0x0c;
      if (CN16_16CHAR[c].Msk[i + k] & 0x10) temp += 0x03;
      write(temp);
      temp = 0;
      if (CN16_16CHAR[c].Msk[i + k] & 0x08) temp += 0xc0;
      if (CN16_16CHAR[c].Msk[i + k] & 0x04) temp += 0x30;
      if (CN16_16CHAR[c].Msk[i + k] & 0x02) temp += 0x0c;
      if (CN16_16CHAR[c].Msk[i + k] & 0x01) temp += 0x03;
      write(temp);
  }
  ky -= 2;
  k += 16;

} while (k < 32);




}
*/


//========================================================================
// 函数: printf_16x16(unsigned x, uchar y, uchar *s)
// 描述: 汉字字符串打印程序 ,不超过10个汉字
// 参数: uchar x :列位值 0-88
// 参数: uchar y :行位值 0-15
// 参数: uchar c :字符数列位置
// 返回:
// 版本: V1.0, 2019-1-9
//========================================================================
/*
void  printf_16x16(unsigned x, uchar y, uchar *s)
{
    uchar l = 0, wordNum;
    while (*s != '\0')
    {
        for (wordNum = 0; wordNum < 12; wordNum++)
        {
            if ((CN16_16CHAR[wordNum].Index[0] == *s)
                    && (CN16_16CHAR[wordNum].Index[1] == *(s + 1)) )
            {
                printc_16x16(x + l, y, wordNum);
                //s++;
                l += 16;
                if ((x + l) > 90) //自动换行
                {
                    y += 4;
                    l = 0;
                    x = 0;
                }
                break; //跳出循环
            }

        }
        s += 2;
    }
}
*/


/*
void printc_16x32(uchar x, unsigned y, uchar c)
{
  printc( x, y, CH16x32,  c)        ;

      uchar k, ky;
      uchar i;    //用于循环
      uchar temp; //编码转换

      y = 15 - y;

  */
/*

for (i = 0; i < 16; i++)                   //8x16
{
    setxy(x + i, y + 2);
    temp = 0;
    if (CN16_32CHAR[c].Msk & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
    if (CN16_32CHAR[c].Msk & 0x40) temp += 0x30; //11最深,01淡,10最淡
    if (CN16_32CHAR[c].Msk & 0x20) temp += 0x0c;
    if (CN16_32CHAR[c].Msk & 0x10) temp += 0x03;
    write(temp);
    temp = 0;
    if (CN16_32CHAR[c].Msk & 0x08) temp += 0xc0;
    if (CN16_32CHAR[c].Msk & 0x04) temp += 0x30;
    if (CN16_32CHAR[c].Msk & 0x02) temp += 0x0c;
    if (CN16_32CHAR[c].Msk & 0x01) temp += 0x03;
    write(temp);
}

for (i = 0; i < 16; i++)           //上半部8x16
{
    setxy(x + i, y);
    temp = 0;
    if (CN16_32CHAR[c].Msk[i + 16] & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
    if (CN16_32CHAR[c].Msk[i + 16] & 0x40) temp += 0x30; //11最深,01淡,10最淡
    if (CN16_32CHAR[c].Msk[i + 16] & 0x20) temp += 0x0c;
    if (CN16_32CHAR[c].Msk[i + 16] & 0x10) temp += 0x03;
    write(temp);
    temp = 0;
    if (CN16_32CHAR[c].Msk[i + 16] & 0x08) temp += 0xc0;
    if (CN16_32CHAR[c].Msk[i + 16] & 0x04) temp += 0x30;
    if (CN16_32CHAR[c].Msk[i + 16] & 0x02) temp += 0x0c;
    if (CN16_32CHAR[c].Msk[i + 16] & 0x01) temp += 0x03;
    write(temp);
}



y = 15 - y;


for (i = 0; i < 16; i++)                   //8x16
{
    setxy(x + i, y + 7);
    temp = 0;
    if (CN16_32CHAR[c].Msk[i + 32] & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
    if (CN16_32CHAR[c].Msk[i + 32] & 0x40) temp += 0x30; //11最深,01淡,10最淡
    if (CN16_32CHAR[c].Msk[i + 32] & 0x20) temp += 0x0c;
    if (CN16_32CHAR[c].Msk[i + 32] & 0x10) temp += 0x03;
    write(temp);
    temp = 0;
    if (CN16_32CHAR[c].Msk[i + 32] & 0x08) temp += 0xc0;
    if (CN16_32CHAR[c].Msk[i + 32] & 0x04) temp += 0x30;
    if (CN16_32CHAR[c].Msk[i + 32] & 0x02) temp += 0x0c;
    if (CN16_32CHAR[c].Msk[i + 32] & 0x01) temp += 0x03;
    write(temp);
}




for (i = 0; i < 16; i++)           //上半部8x16
{
    setxy(x + i, y + 5);
    temp = 0;
    if (CN16_32CHAR[c].Msk[i + 48] & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
    if (CN16_32CHAR[c].Msk[i + 48] & 0x40) temp += 0x30; //11最深,01淡,10最淡
    if (CN16_32CHAR[c].Msk[i + 48] & 0x20) temp += 0x0c;
    if (CN16_32CHAR[c].Msk[i + 48] & 0x10) temp += 0x03;
    write(temp);
    temp = 0;
    if (CN16_32CHAR[c].Msk[i + 48] & 0x08) temp += 0xc0;
    if (CN16_32CHAR[c].Msk[i + 48] & 0x04) temp += 0x30;
    if (CN16_32CHAR[c].Msk[i + 48] & 0x02) temp += 0x0c;
    if (CN16_32CHAR[c].Msk[i + 48] & 0x01) temp += 0x03;
    write(temp);
}

*/




/*
  k = 0;
  ky = 2;

  do
  {

      for (i = 0; i < 16; i++)                   //8x8
      {
          setxy(x + i, y + ky);
          temp = 0;
          if (CN16_32CHAR[c].Msk[i + k] & 0x80) temp += 0xc0; //灰度转换,这里可以根据需要,写不同的灰度
          if (CN16_32CHAR[c].Msk[i + k] & 0x40) temp += 0x30; //11最深,01淡,10最淡
          if (CN16_32CHAR[c].Msk[i + k] & 0x20) temp += 0x0c;
          if (CN16_32CHAR[c].Msk[i + k] & 0x10) temp += 0x03;
          write(temp);
          temp = 0;
          if (CN16_32CHAR[c].Msk[i + k] & 0x08) temp += 0xc0;
          if (CN16_32CHAR[c].Msk[i + k] & 0x04) temp += 0x30;
          if (CN16_32CHAR[c].Msk[i + k] & 0x02) temp += 0x0c;
          if (CN16_32CHAR[c].Msk[i + k] & 0x01) temp += 0x03;
          write(temp);
      }

      if (ky == 0)
      {
          ky = 9 ;                        //为什么是9?
          y = 15 - y ;
      }

      ky -= 2;
      k += 16;




  } while (k < 64 );


}

*/
/*
void printf_16x32(unsigned x, uchar y, uchar *s)
{
    uchar l = 0, wordNum;
    while (*s != '\0')
    {
        for (wordNum = 0; wordNum < 12; wordNum++)         //从50个数组中查找
        {
            if (CN16_32CHAR[wordNum].Index[0] == *s)
            {
                printc_16x32(x + l, y, wordNum);
                //s++;
                l += 16;
                if ((x + l) > 90) //自动换行
                {
                    y += 8;
                    l = 0;
                    x = 0;
                }

                break; //跳出循环
            }

        }
        s++;
    }
}
*/








#endif

回复 支持 反对

使用道具 举报

 楼主| 发表于 2019-9-6 22:54:49 | 显示全部楼层

ADC.h

本帖最后由 面条数码 于 2019-9-7 00:21 编辑

//  ADC.h

#ifndef __ADC_H__
#define __ADC_H__



#include "HC89F003.h"
#include "sys.h"


/***************************************************************************************
  * @说明          ADC初始化
  *        @参数        无
  * @返回值 无
  * @注                选择外部通道0,转换结果12位数据,高八位置于ADCRH寄存器,ADC时钟16分频
***************************************************************************************/
void ADC_Init(void)
{


         ADCC0 = 0x83;                                                //打开ADC转换电源,选择内部参考电压2伏。
//        ADCC1 = 0x05;                                                //选择外部通道0
        ADCC2 = 0x0D;                                                //转换结果12位数据,高八位置于ADCRH寄存器,ADC时钟16分频



}

/***************************************************************************************
  * @说明          IO初始化
  *        @参数        无
  * @返回值 无\
  * @注P00,P01口设置为模拟输入,P02设为带上拉输入,P03,P04设为开漏带上拉输出,P20设为推挽输出

      1                  2                  3                  4                  5                 6                  7                  8
MCU          VDD          P20          P04         P03         P02         P01         P00          GND
ISP                                                                                         RXD         TXD
MCU           INT8          INT4         INT3    INT2    INT1         INT0
MCU           AN8          AN4         AN3     AN2     AN1         AN0
LCD                          RST          SCL    SDA                 
KEY                                  KEY1
                                                                  
***************************************************************************************/


void ADC_IO_Init(void)
{

#ifdef        ZDQ

P0M0 = P0M0&0xF0|0x02;//P0.0带上拉输入(非施密特)
P0M0 = P0M0&0x0F|0xA0;//P0.1开漏带上拉输出
P0M1 = P0M1&0xF0|0x03;//P0.2模拟输入
P0M1 = P0M1&0x0F|0x30;//P0.3模拟输入
P0M2 = P0M2&0xF0|0x0A;//P0.4开漏带上拉输出
P2M0 = P2M0&0xF0|0x0A;//P2.0开漏带上拉输出

#else
/*
        P0M0 = 0x33;        //P0.1模拟输入|P0.0模拟输入        
        P0M1 = 0xa2;        //P0.3开漏带上拉输出|P0.2带上拉输入(非施密特)                                 
        P0M2 = 0x3a;   //P0.5模拟输入|P0.4开漏带上拉输出
//        P2M0 = 0x38;   //P2.1模拟输入|P2.0推挽输出
    P2M0 = 0x3A;//P2.1模拟输入|P2.0开漏带上拉输出
*/
P0M0 = P0M0&0xF0|0x07;//P0.0保留(模拟输入)
P0M0 = P0M0&0x0F|0x70;//P0.1保留(模拟输入)
P0M1 = P0M1&0xF0|0x02;//P0.2带上拉输入(非施密特)
P0M1 = P0M1&0x0F|0xA0;//P0.3开漏带上拉输出
P0M2 = P0M2&0xF0|0x0A;//P0.4开漏带上拉输出
P2M0 = P2M0&0xF0|0x0A;//P2.0开漏带上拉输出


#endif
                           
}




//========================================================================
// 函数: uint    GetADC12bitResult(uchar ch)
// 描述: 查询法读一次ADC结果.
// 参数: ch: 选择要转换的ADC.        //channel = 0~7
// 返回: 12位ADC结果.
// 版本: V1.0, 2019-1-9
//========================================================================
u16 GetADC12bitResult(unsigned char  ch)           //channel = 0~7
{
    u16 ADC_12BIT_RES;

    ADCC1 = ch;                                                     //选择外部通道ch
        ADCC0 |= 0x40;                                                //启动ADC转换
        while(!(ADCC0&0x20));                                //等待ADC转换结束
        ADCC0 &=~ 0x20;                                                //清除标志位
        ADC_12BIT_RES = ADCRH;
        ADC_12BIT_RES = (ADC_12BIT_RES<<4)|ADCRL;                        //ADC的值


    return ADC_12BIT_RES;                 //返回ADC结果

}



#endif
回复 支持 反对

使用道具 举报

 楼主| 发表于 2019-9-6 22:55:45 | 显示全部楼层

FLASH.h

本帖最后由 面条数码 于 2019-9-7 00:22 编辑

//flash.h    数据存取

#ifndef __FLASH_H__
#define __FLASH_H__
#include <HC89F003.H>

#include <DELAY.H>



/// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                   应用注意事项
//  1、CPU时钟需要配置为1-16MHz之间的正整数,且Flash擦写之前需要配置FREQ_CLK寄存器,该寄
//     存器值即为当前CPU时钟频率。
//  2、扇区擦除写入过程中不能被打断
//  3、数据存放地址需要在程序存放地址之后
//  4、第二复位向量使能时,无法在仿真环境下查看code区数据
//   5、Flsah操作最低电压限制为2.0V,所以建议进行Flash操作前进行电压检测或者打开BOR,BOR电
//      压建议设置为2.4V及2.4V以上
//  6、建议在进行Flash擦写操作前关闭中断,擦写完成后再打开中断
//  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
// @说明      扇区擦除,约消耗5ms的时间
// @参数      fui_Address :被擦除的扇区内的任意一个地址
// @返回值 无
// @注        只要操作扇区里面的任意一个地址,就可以擦除此扇区
///


//#define IAP_ADDRESS 0x2B00
#define IAP_ADDRESS 0x2D00                 //11520bit
//========================================================================
//
// 描述: HC890411P ROM为12k大小,0x2B00 =  11008 bit; 读写在代码区11k字节之后
// 本程序编译后大小不得超过11k字节,否则无法保存参数
// 版本: V1.0, 2019-1-9
//        2D00 = 115200
//========================================================================



///
#pragma disable                         //确保调整时不会进中断导致调整失败
void Flash_EraseBlock(unsigned int fui_Address)
{
    IAP_CMD = 0xF00F;               //Flash解锁
    IAP_ADDR = fui_Address;         //写入擦除地址
    IAP_CMD = 0xD22D;               //选择操作方式, 扇区擦除
    IAP_CMD = 0xE11E;               //触发后IAP_ADDRL&IAP_ADDRH指向0xFF,同时自动锁定
}
///
///
// @说明      写入一个字节数据到Flash里面
// @参数      fui_Address :FLASH地址
//    @参数   fucp_SaveData:写入的数据
// @返回值 无
// @注        写之前必须先对操作的扇区进行擦除
///
#pragma disable                         //确保调整时不会进中断导致调整失败
void FLASH_WriteData(unsigned char fuc_SaveData, unsigned int fui_Address)
{
    IAP_DATA = fuc_SaveData;
    IAP_CMD = 0xF00F;           //Flash解锁
    IAP_ADDR = fui_Address;
    IAP_CMD = 0xB44B;           //字节编程
    IAP_CMD = 0xE11E;           //触发一次操作
}

///
// @说明      写入任意长度的数据到FLASH里面
// @参数      fui_Address :FLASH起始地址
//    @参数   fuc_Length : 写入数据长度
//            取值范围:0x00-0xFF
//    @参数   //fucp_SaveArr:写入的数据存放区域的首地址
// @返回值 无
// @注        写之前必须先对操作的扇区进行擦除
///
#pragma disable                         //确保调整时不会进中断导致调整失败
void Flash_WriteArr(unsigned int fui_Address, unsigned char fuc_Length,
                    unsigned char *fucp_SaveArr)
{
    unsigned char fui_i = 0;
    for (fui_i = 0; fui_i < fuc_Length; fui_i++)
    {
        FLASH_WriteData(*(fucp_SaveArr++), fui_Address++);
    }
}

///
// @说明      从FLASH里面读取任意长度的数据
// @参数      fui_Address :FLASH起始地址
//    @参数   fuc_Length :读取数据长度
//            取值范围:0x00-0xFF
//    @参数   //fucp_SaveArr:读取数据存放的区域首地址
// @返回值 无
// @注        无
///
void Flash_ReadArr(unsigned int fui_Address, unsigned char fuc_Length,
                   unsigned char *fucp_SaveArr)
{
    while (fuc_Length--)
        *(fucp_SaveArr++) = *((unsigned char code *)(fui_Address++)); //读取数据
}


///////////////////////////Flash配置初始化/////////////////////////////////////////////////////////
void Flash_INIT(void)
{
    FREQ_CLK = 0x10;                    //指明当前系统时钟
}

#endif
回复 支持 反对

使用道具 举报

 楼主| 发表于 2019-9-6 22:56:34 | 显示全部楼层

SYS.h

本帖最后由 面条数码 于 2019-9-7 00:22 编辑

//sys.h    系统设置


#ifndef __SYS_H__
#define __SYS_H__


#include "HC89F003.h"

//#define ZDQ




typedef signed char             s8;
typedef signed int              s16;
typedef signed long             s32;

typedef unsigned char           u8;
typedef unsigned int            u16;
typedef unsigned long           u32;

typedef volatile unsigned char  vu8;
typedef volatile unsigned int   vu16;
typedef volatile unsigned long  vu32;

typedef enum
{
    FALSE = 0,
    TRUE = !FALSE
} bool;

typedef enum
{
    RESET = 0,          //设置
    SET = !RESET        //重置
} FlagStatus;

typedef enum
{
    DISABLE = 0,        //失能
    ENABLE = !DISABLE   //使能
} FunctionalState;

typedef enum
{
    ERROR = 0,          //出错
    SUCCESS = !ERROR    //成功
} ErrorStatus;



//u32 osc_clk, cpu_clk;


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// @说明    系统初始化
//  @参数   无
// @返回值 无
// @注      关闭看门狗以及时钟初始化
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void System_init(void)
{

    /*
    WDTCCR = 0x00;                                  //关闭看门狗
    while ((CLKCON & 0x20) != 0x20);                    //等待内部高频晶振起振
    CLKDIV = 0x02;                                  //CPU时钟2分频,确保在进行RC32分频时CPU时钟小于20M , 32Mhz / 2 = 16MHZ
    //CLKDIV = 0x04;                                    //CPU时钟4分频,确保在进行RC32分频时CPU时钟小于20M , 32Mhz / 4 = 8MHZ

    CLKSWR = 0x51;                                  //选择内部高频时钟为主时钟,且内部高频RC2分频
//    osc_clk =   16000000UL;                         //定义主时钟
    while ((CLKSWR & 0xC0) != 0x40);                    //等待内部高频切换完成

  */


         WDTCCR = 0x00;                                                //关闭看门狗
                                                //本例程为方便测试关闭看门狗,实际使用中,建议客户打开看门狗,详见WDT复位例程
        CLKSWR = 0x51;                                                //选择内部高频RC为系统时钟,内部高频RC 2分频,Fosc=16MHz
        CLKDIV = 0x01;                                                //Fosc 1分频得到Fcpu,Fcpu=16MHz

   

// cpu_clk = 16000000UL;                            //定义CPU时钟



}


#endif
回复 支持 反对

使用道具 举报

 楼主| 发表于 2019-9-6 23:27:54 | 显示全部楼层

HC89F003.H

本帖最后由 面条数码 于 2019-9-7 00:22 编辑

//HC89F003 头文件,通用的
/*--------------------------------------------------------------------------
HC89F003.H

Header file for generic HC89F003 series microcontroller.
Copyright (c) 2009-2015 Shanghai Holychip Electronic Technology Co., Ltd.
All rights reserved.
--------------------------------------------------------------------------*/
#ifndef __HC89F003_H__
#define __HC89F003_H__

/* ------------------- BYTE Register-------------------- */
/* CPU */
sfr   PSW       = 0xD0;
sfr   ACC       = 0xE0;
sfr   B         = 0xF0;
sfr   SP        = 0x81;
sfr   DPL       = 0x82;
sfr   DPH       = 0x83;
sfr   INSCON    = 0xA2;
sfr16 DPTR      = 0x82;

/* SYS CLOCK  */
sfr   CLKSWR    = 0x8E;
sfr   CLKCON    = 0x8F;

/* POWER  */
sfr   PCON      = 0x87;

/* FLASH */
sfr   IAP_ADDRL = 0xF9;
sfr   IAP_ADDRH = 0xFA;
sfr   IAP_DATA  = 0xFB;
sfr   IAP_CMDL  = 0xFC;
sfr   IAP_CMDH  = 0xFD;

sfr16 IAP_ADDR  = 0xF9;
sfr16 IAP_CMD   = 0xFC;

/* REST */
sfr   RSTFR     = 0xF8;

/* WDT  */
sfr   WDTC      = 0xBD;

/* INTERRUPT */
sfr   IE        = 0xA8;
sfr   IE1       = 0xB8;
sfr   IP0       = 0xA9;
sfr   IP1       = 0xAA;
sfr   IP2       = 0xB9;
sfr   IP3       = 0xBA;

sfr   PINTF0    = 0x96;
sfr   PINTF1    = 0x97;

/* PORT */
sfr   P0        = 0x80;
sfr   P1        = 0x90;
sfr   P2        = 0xA0;

/* TIMER */
sfr   TCON      = 0x88;
sfr   TMOD      = 0x89;
sfr   TL0       = 0x8A;
sfr   TL1       = 0x8B;
sfr   TH0       = 0x8C;
sfr   TH1       = 0x8D;

sfr   T3CON     = 0xC9;
sfr   TL3       = 0xCA;
sfr   TH3       = 0xCB;
sfr16 T3        = 0xCA;

sfr   T4CON     = 0xCC;
sfr   TL4       = 0xCD;
sfr   TH4       = 0xCE;
sfr16 T4        = 0xCD;

sfr   T5CON     = 0xC1;
sfr   TL5       = 0xC2;
sfr   TH5       = 0xC3;
sfr   RCAP5L    = 0xC4;
sfr   RCAP5H    = 0xC5;
sfr16 T5        = 0xC2;
sfr16 RCAP5     = 0xC4;

/* UART */
sfr   SCON      = 0x98;
sfr   SBUF      = 0x99;
sfr   SADDR     = 0x9A;
sfr   SADEN     = 0x9B;
sfr   SCON2     = 0x9E;

/* SPI */
sfr   SPDAT     = 0xAB;
sfr   SPCTL     = 0xAC;
sfr   SPSTAT    = 0xAD;

/* ADC */
sfr   ADCC0     = 0xB4;
sfr   ADCC1     = 0xB5;
sfr   ADCRL     = 0xB6;
sfr   ADCRH     = 0xB7;
sfr16 ADCR      = 0xB6;

/* CRC */
sfr   CRCL      = 0xBE;
sfr   CRCH      = 0xBF;
sfr16 CRCR      = 0xBE;

/* PWM */
sfr   PWM0C     = 0xDA;
sfr   PWM1C     = 0xDB;
sfr   PWM2C     = 0xDC;
sfr   PWM3C     = 0xDD;
sfr   PWM3P     = 0xDE;
sfr   PWM3D     = 0xDF;
sfr   PWM0EN    = 0xE1;
sfr   PWM0PL    = 0xE2;
sfr   PWM0PH    = 0xE3;
sfr   PWM0DL    = 0xE4;
sfr   PWM0DH    = 0xE5;
sfr   PWM0DTL   = 0xE6;
sfr   PWM0DTH   = 0xE7;
sfr   PWM1EN    = 0xE9;
sfr   PWM1PL    = 0xEA;
sfr   PWM1PH    = 0xEB;
sfr   PWM1DL    = 0xEC;
sfr   PWM1DH    = 0xED;
sfr   PWM1DTL   = 0xEE;
sfr   PWM1DTH   = 0xEF;
sfr   PWM2EN    = 0xF1;
sfr   PWM2PL    = 0xF2;
sfr   PWM2PH    = 0xF3;
sfr   PWM2DL    = 0xF4;
sfr   PWM2DH    = 0xF5;
sfr   PWM2DTL   = 0xF6;
sfr   PWM2DTH   = 0xF7;

sfr16 PWM0P     = 0xE2;
sfr16 PWM0D     = 0xE4;
sfr16 PWM0DT    = 0xE6;
sfr16 PWM1P     = 0xEA;
sfr16 PWM1D     = 0xEC;
sfr16 PWM1DT    = 0xEE;
sfr16 PWM2P     = 0xF2;
sfr16 PWM2D     = 0xF4;
sfr16 PWM2DT    = 0xF6;

/* LVD */
sfr   LVDC      = 0xBB;

/*--------------------------  BIT Register -------------------- */
/*  PSW   */
sbit  CY        = PSW^7;
sbit  AC        = PSW^6;
sbit  F0        = PSW^5;
sbit  RS1       = PSW^4;
sbit  RS0       = PSW^3;
sbit  OV        = PSW^2;
sbit  F1        = PSW^1;
sbit  P         = PSW^0;

/*  IE   */
sbit  EA        = IE^7;
sbit  ES2       = IE^6;
sbit  EWDT      = IE^5;
sbit  ES1       = IE^4;
sbit  ET1       = IE^3;
sbit  EX1       = IE^2;
sbit  ET0       = IE^1;
sbit  EX0       = IE^0;

/*  IE1   */
sbit  EX8_15    = IE1^7;
sbit  EX2_7     = IE1^6;
sbit  EADC      = IE1^5;
sbit  ET5       = IE1^4;
sbit  ET4       = IE1^2;
sbit  ET3       = IE1^1;
sbit  ESPI      = IE1^0;

/*  RSTFR   */
sbit  PORF      = RSTFR^7;
sbit  EXRSTF    = RSTFR^6;
sbit  BORF      = RSTFR^5;
sbit  WDTRF     = RSTFR^4;
sbit  SWRF      = RSTFR^3;
sbit  SPOVF     = RSTFR^1;
sbit  PLVRSTF   = RSTFR^0;

/*  SCON  */
sbit  FE        = SCON^7;
sbit  RXROV     = SCON^6;
sbit  TXCOL     = SCON^5;
sbit  REN       = SCON^4;
sbit  TB8       = SCON^3;
sbit  RB8       = SCON^2;
sbit  TI        = SCON^1;
sbit  RI        = SCON^0;

/*  TCON  */
sbit TF1        = TCON^7;
sbit TR1        = TCON^6;
sbit TF0        = TCON^5;
sbit TR0        = TCON^4;

// /* P0 */
// sbit P0_0       = P0^0;
// sbit P0_1       = P0^1;
// sbit P0_2       = P0^2;
// sbit P0_3       = P0^3;
// sbit P0_4       = P0^4;
// sbit P0_5       = P0^5;
// sbit P0_6       = P0^6;
// sbit P0_7       = P0^7;

// /* P1 */
// sbit P1_0       = P1^0;
// sbit P1_1       = P1^1;

// /* P2 */
// sbit P2_0       = P2^0;
// sbit P2_1       = P2^1;
// sbit P2_2       = P2^2;
// sbit P2_3       = P2^3;
// sbit P2_4       = P2^4;
// sbit P2_5       = P2^5;
// sbit P2_6       = P2^6;
// sbit P2_7       = P2^7;


/* XSFR_TIMER */
#define TCON1       (*(unsigned char volatile xdata *) 0xFE80) //

/* XSFR_PCA */
#define T5CON1      (*(unsigned char volatile xdata *) 0xFE85) //

/* XSFR_UART2 */
#define S2CON       (*(unsigned char volatile xdata *) 0xFE88) //
#define S2CON2      (*(unsigned char volatile xdata *) 0xFE89) //
#define S2BUF       (*(unsigned char volatile xdata *) 0xFE8A) //

/* XSFR_SYSCLK */
#define CLKDIV      (*(unsigned char volatile xdata *) 0xFE91) //
#define FREQ_CLK    (*(unsigned char volatile xdata *) 0xFE92) //
#define CLKOUT      (*(unsigned char volatile xdata *) 0xFE93) //
#define SPOV_RSTEN  (*(unsigned char volatile xdata *) 0xFE95) //

/* XSFR_ADC */
#define ADCWC       (*(unsigned char volatile xdata *) 0xFE98) //
#define ADCC2       (*(unsigned char volatile xdata *) 0xFE9B) //


/* XSFR_WDT */
#define WDTCCR      (*(unsigned char volatile xdata *) 0xFEA0) //

/* XSFR_CRC */
#define CRCC        (*(unsigned char volatile xdata *) 0xFEA2) //

/* XSFR_BOR */
#define BORC        (*(unsigned char volatile xdata *) 0xFEA4) //
#define BORDBC      (*(unsigned char volatile xdata *) 0xFEA5) //


/* XSFR_LVD */
#define LVDDBC      (*(unsigned char volatile xdata *) 0xFEA7) //

/* XSFR_RST */
#define RSTDBC      (*(unsigned char volatile xdata *) 0xFEAA) //


/* XSFR_PITS */
#define PITS0       (*(unsigned char volatile xdata *) 0xFEB0) //
#define PITS1       (*(unsigned char volatile xdata *) 0xFEB1) //
#define PITS2       (*(unsigned char volatile xdata *) 0xFEB2) //
#define PITS3       (*(unsigned char volatile xdata *) 0xFEB3) //

#define PINTE0      (*(unsigned char volatile xdata *) 0xFEB8) //
#define PINTE1      (*(unsigned char volatile xdata *) 0xFEB9) //

#define INT01_PINS  (*(unsigned char volatile xdata *) 0xFEBC)

/* XSFR_PORT */
#define P0M0        (*(unsigned char volatile xdata *) 0xFF00) //
#define P0M1        (*(unsigned char volatile xdata *) 0xFF01) //
#define P0M2        (*(unsigned char volatile xdata *) 0xFF02) //
#define P0M3        (*(unsigned char volatile xdata *) 0xFF03) //

#define P0LPU       (*(unsigned char volatile xdata *) 0xFF05) //

#define P1M0        (*(unsigned char volatile xdata *) 0xFF08) //

#define P2M0        (*(unsigned char volatile xdata *) 0xFF10) //
#define P2M1        (*(unsigned char volatile xdata *) 0xFF11) //
#define P2M2        (*(unsigned char volatile xdata *) 0xFF12) //
#define P2M3        (*(unsigned char volatile xdata *) 0xFF13) //

#define P00DBC      (*(unsigned char volatile xdata *) 0xFF40) //
#define P01DBC      (*(unsigned char volatile xdata *) 0xFF41) //
#define P02DBC      (*(unsigned char volatile xdata *) 0xFF42) //

/* XSFR_MAP */
#define T0_MAP      (*(unsigned char volatile xdata *) 0xFF80) //  
#define T1_MAP      (*(unsigned char volatile xdata *) 0xFF81) //
#define T3_MAP      (*(unsigned char volatile xdata *) 0xFF83) //
#define T4_MAP      (*(unsigned char volatile xdata *) 0xFF84) //
#define T5_MAP      (*(unsigned char volatile xdata *) 0xFF85) //
#define CLKO_MAP    (*(unsigned char volatile xdata *) 0xFF8F) //

#define PWM0_MAP    (*(unsigned char volatile xdata *) 0xFF90) //
#define PWM01_MAP   (*(unsigned char volatile xdata *) 0xFF91) //

#define PWM1_MAP    (*(unsigned char volatile xdata *) 0xFF94) //
#define PWM11_MAP   (*(unsigned char volatile xdata *) 0xFF95) //

#define PWM2_MAP    (*(unsigned char volatile xdata *) 0xFF98) //
#define PWM21_MAP   (*(unsigned char volatile xdata *) 0xFF99) //

#define PWM3_MAP    (*(unsigned char volatile xdata *) 0xFF9C) //

#define TXD_MAP     (*(unsigned char volatile xdata *) 0xFFA0) //
#define RXD_MAP     (*(unsigned char volatile xdata *) 0xFFA1) //

#define SS_MAP      (*(unsigned char volatile xdata *) 0xFFA4) //
#define SCK_MAP     (*(unsigned char volatile xdata *) 0xFFA5) //
#define MOSI_MAP    (*(unsigned char volatile xdata *) 0xFFA6) //
#define MISO_MAP    (*(unsigned char volatile xdata *) 0xFFA7) //
#define TXD2_MAP    (*(unsigned char volatile xdata *) 0xFFA8) //
#define RXD2_MAP    (*(unsigned char volatile xdata *) 0xFFA9) //

/*------------------------------------------------
Interrupt Vectors:
Interrupt Address = (Number * 8) + 3
------------------------------------------------*/
#define INT0_VECTOR    0   /* 0x03 EXTERNal Interrupt 0 */
#define TIMER0_VECTOR  1   /* 0x0B Timer 0 */
#define INT1_VECTOR    2   /* 0x13 EXTERNal Interrupt 1 */
#define TIMER1_VECTOR  3   /* 0x1B Timer 1 */
#define UART1_VECTOR   4   /* 0x23 Serial port 1 */
#define WDT_VECTOR     5   /* 0x2B WDT */
#define LVD_VECTOR     6   /* 0x33 LVD */
#define UART2_VECTOR   7   /* 0x3B Serial port 2 */
#define SPI_VECTOR     8   /* 0x43 SPI */
#define T3_VECTOR      9   /* 0x4B Timer 3 */
#define T4_VECTOR      10  /* 0x53 Timer 4 */
#define PWM_VECTOR     11  /* 0x5B PWM */
#define T5_VECTOR      12  /* 0x63 Timer 5 */
#define ADC_VECTOR     13  /* 0x6B ADC */
#define INT2_7_VECTOR  14  /* 0x73 INT2~INT7 */
#define INT8_15_VECTOR 15  /* 0x7B INT8~INT15 */

#endif/* __HC89F003_H__ */
回复 支持 反对

使用道具 举报

 楼主| 发表于 2019-9-7 08:02:05 | 显示全部楼层
//按键处理,只有一个按键,分长按和短按

/////==============================================================================
//// 函数名称: key1ShortPress
//// 功能描述: 短按
//// 参数说明: None
//// 返回说明: None
//// 创建人员: jam,QQ422470459
//// 创建日期: 2019-01-28
////------------------------------------------------------------------------------
//// 修改人员:jam
//// 修改日期:2019-01-28
//// 修改描述:
/////==============================================================================

void key1ShortPress(void)    //短按
{


    switch (DISPLAYmode)
    {
    case DISPLAY_HOME:

        DISPLAYmode += 4;   //在首页界面,直接跳到末页
        B_home = !B_home ;  //  首页是否轮换显示
        break;


    case DISPLAY_ADJV:
    case DISPLAY_ADJI:
    case DISPLAY_REPORT:
    case DISPLAY_REPORT2:
        switch (ADJmode)
        {
        case ADJ_QUIT:
            if (DISPLAYmode == DISPLAY_REPORT)
            {
                B_ReportEdit = 0;
                SaveCfg();
            }

            DISPLAYmode ++;
            if (DISPLAYmode > DISPLAY_REPORT2 )
            {
                DISPLAYmode = DISPLAY_HOME;
                HOMEmode ++;
                if (HOMEmode > DISPLAY_HOME4 )
                {
                    HOMEmode =  DISPLAY_HOME0;
                }
            }
            LCD_cls();

            break;

        case ADJ_ADD:

            switch (DISPLAYmode)
            {
            case DISPLAY_ADJV:
                // adj_Vratio += 1;

                if (adj_Vratio & 0x80 )  //最高位表示负数
                {
                    adj_Vratio -= 1;
                }
                else
                {
                    adj_Vratio += 1;
                }

                //每次调节1%%
                if  ((adj_Vratio & 0x7F ) > 100)  adj_Vratio   = 0x00 ;
                break;
            case DISPLAY_ADJI:
                //adj_Iratio += 1;
                if (adj_Iratio & 0x80 )  //最高位表示负数
                {
                    adj_Iratio -= 1;
                }
                else
                {
                    adj_Iratio += 1;
                }
                //每次调节1%%
                if  ((adj_Iratio & 0x7F ) > 100)  adj_Iratio   = 0x00 ;
                break;

            case DISPLAY_REPORT:


                maxA10 += 10;                               //每次调节10
                if (maxA10 > 90)  maxA10 = 10;


                break;


            default:
                break;
            }

            break;

        case ADJ_MINUS:

            switch (DISPLAYmode)
            {

            case DISPLAY_ADJV:


                if (adj_Vratio == 0x00 )
                {
                    adj_Vratio |= 0x80 ;
                }

                if (adj_Vratio & 0x80 )  //最高位表示负数
                {
                    adj_Vratio += 1;
                }
                else
                {
                    adj_Vratio -= 1;
                }

                //每次调节1%%
                if        ( adj_Vratio > 0xE4)          adj_Vratio  = 0xE4 ;
                break;

            case DISPLAY_ADJI:

                if (adj_Iratio == 0x00 )
                {
                    adj_Iratio |= 0x80 ;
                }

                if (adj_Iratio & 0x80 )  //最高位表示负数
                {
                    adj_Iratio += 1;
                }
                else
                {
                    adj_Iratio -= 1;
                }

                //每次调节1%%
                if        ( adj_Iratio > 0xE4)          adj_Iratio  = 0xE4 ;
                break;

            case DISPLAY_REPORT:
                minA10 += 1;                                                              //每次调节10
                if (minA10 > 9)  minA10 = 0;

                break;


            default:
                break;
            }



        default:
            break;
        }



        break;

    case DISPLAY_TIME:

        switch (TEDITmode)
        {

        case TEDIT_QUIT:
            B_Tedit = 0;
            DISPLAYmode++;
            LCD_cls();
            break;

        case TEDIT_MINUTE:
            minute++;
            if (minute > 59)
                minute = 0;

            break;

        case TEDIT_HOUR:
            hour++;
            if (hour > 23)
                hour = 0;
            break;
        case TEDIT_DAY:
            day++;
            if (day > 31)
                day = 1;
            break;

        case TEDIT_MONTH:
            month++;
            if (month > 12)
                month = 1;

            break;
        case TEDIT_YEAR:
            year++;
            if (year > 50)
                year = 18;
            break;

        case TEDIT_WDTCCR:
            WDTCCR_f++;
            if (WDTCCR_f > 206)
                WDTCCR_f = 136;
            break;

        default:
            break;
        }


        break;
    default:

        DISPLAYmode++;
        break;
    }




}




/////==============================================================================
//// 函数名称: key1LongPress
//// 功能描述: key1长按
//// 参数说明: None
//// 返回说明: None
//// 创建人员: jam,QQ422470459
//// 创建日期: 2019-01-28
////------------------------------------------------------------------------------
//// 修改人员:jam
//// 修改日期:2019-01-28
//// 修改描述:
/////==============================================================================

void key1LongPress(void) //长按
{


    switch (DISPLAYmode)
    {
    case DISPLAY_HOME:
        B_Tedit = 1;
        B_ReportEdit = 1;
        DISPLAYmode++;
        LCD_cls();
        break;
    case DISPLAY_TIME:
        B_Tedit = 1;
        TEDITmode++;
        if (TEDITmode > TEDIT_WDTCCR )
        {   TEDITmode = TEDIT_QUIT;

            LCD_cls();
        }
        break;


    case DISPLAY_REPORT:
        B_ReportEdit = 1;
    case DISPLAY_ADJV:
    case DISPLAY_ADJI:
        ADJmode++;                                                        //调整模式切换
        if (ADJmode > ADJ_MINUS )
            ADJmode = ADJ_QUIT;
        break;
    case DISPLAY_REPORT2:
        CHARTmode = !CHARTmode;
        LCD_cls();
        break;

    default:
        DISPLAYmode++;                                                   //显示模式切换
        if (DISPLAYmode > DISPLAY_REPORT ) DISPLAYmode = DISPLAY_HOME;
        LCD_cls();
        break;
    }



}



/////==============================================================================
//// 函数名称: key1Scan
//// 功能描述: 按键处理函数,短按和长按.
//// 参数说明: None
//// 返回说明: None
//// 创建人员: jam,QQ422470459
//// 创建日期: 2019-01-28
////------------------------------------------------------------------------------
//// 修改人员:jam
//// 修改日期:2019-01-28
//// 修改描述:
/////==============================================================================

void key1Scan(void)
{
//////////////////////////此区间不要修改///////////////////////////////////////////////////////////////////////////////////////
    if (key1 == 0 && key1_SPress == 0)               // 加
    {
        keypressTime = KEYPRESSTIME;       //按压时间4个循环,约1秒
        key1_SPress = 1;        //按键标志,防止重复计数

    }
    //key1按下且超过4个循环---长按,执行长按程序
    else if (key1 == 0 &&
             key1_SPress &&
             key1_LPress == 0 &&
             keypressTime == 0)
    {
        key1_LPress = 1;

//////////////////////////此区间不要修改///////////////////////////////////////////////////////////////////////////////////////

        //执行长按程序
        key1LongPress()  ;



//////////////////////////此区间不要修改///////////////////////////////////////////////////////////////////////////////////////////////
    }

    else if (key1 &&
             key1_SPress  &&
             key1_LPress == 0) //key1抬起 ,且已按过key1---短按,执行短按程序
    {
        key1_SPress = 0;

/////////////////////////此区间不要修改///////////////////////////////////////////////////////////////////////////////////////////
        //执行短按函数

        key1ShortPress();    //短按


//////////////////////////此区间不要修改///////////////////////////////////////////////////////////////////////////////////////

    }
    else if (key1)
    {
        key1_SPress = 0;
        key1_LPress = 0;
    }

    if (keypressTime != 0 )  //按键计数器计时
    {
        keypressTime--;
    }

//////////////////////////此区间不要修改///////////////////////////////////////////////////////////////////////////////////////

}

回复 支持 反对

使用道具 举报

发表于 2019-9-7 08:50:09 来自手机浏览器 | 显示全部楼层
003f4那个能用吗?

点评

内核都不一样  详情 回复 发表于 2019-9-7 11:29
回复 支持 反对

使用道具 举报

发表于 2019-9-7 08:52:11 | 显示全部楼层
技术贴,支持
回复 支持 反对

使用道具 举报

发表于 2019-9-7 11:29:00 | 显示全部楼层
辛苦了 支持下
回复 支持 反对

使用道具 举报

发表于 2019-9-7 11:29:28 | 显示全部楼层

内核都不一样

点评

我说的是那个hc003f4跟这个内核也不一样吗?  详情 回复 发表于 2019-9-7 21:09
回复 支持 反对

使用道具 举报

发表于 2019-9-7 12:04:47 来自手机浏览器 | 显示全部楼层
多谢楼主分享
回复 支持 反对

使用道具 举报

发表于 2019-9-7 17:25:15 | 显示全部楼层
关注过的,当时觉得取样电阻100毫欧好像有点大了点。
回复 支持 反对

使用道具 举报

发表于 2019-9-7 17:35:30 | 显示全部楼层
谢谢分享。这帖子弄得我心痒痒的,看样子也要剁手败回来玩玩。。。。

点评

我鲁了俩,结果到手一个白屏,准备刷刷固件看看是不是漏刷了  详情 回复 发表于 2019-9-8 17:46
回复 支持 反对

使用道具 举报

发表于 2019-9-7 21:09:11 来自手机浏览器 | 显示全部楼层
2545889167 发表于 2019-9-7 11:29
内核都不一样

我说的是那个hc003f4跟这个内核也不一样吗?

点评

我以为你说stm8s003  详情 回复 发表于 2019-9-7 21:12
回复 支持 反对

使用道具 举报

发表于 2019-9-7 21:12:40 | 显示全部楼层
触景情伤 发表于 2019-9-7 21:09
我说的是那个hc003f4跟这个内核也不一样吗?

我以为你说stm8s003
回复 支持 反对

使用道具 举报

发表于 2019-9-8 17:46:20 | 显示全部楼层
温力口 发表于 2019-9-7 17:35
谢谢分享。这帖子弄得我心痒痒的,看样子也要剁手败回来玩玩。。。。

我鲁了俩,结果到手一个白屏,准备刷刷固件看看是不是漏刷了
回复 支持 反对

使用道具 举报

发表于 2019-9-8 18:46:19 | 显示全部楼层
帮顶!:lol::lol:
回复 支持 反对

使用道具 举报

发表于 2019-9-9 06:38:36 | 显示全部楼层
请问这单片机用什么编译软件?谢谢。

点评

51核,keil  详情 回复 发表于 2019-9-12 12:00
好像还是keil…  详情 回复 发表于 2019-9-9 09:20
回复 支持 反对

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册 微信登录

本版积分规则

Archiver|手机版|小黑屋|关于我们|联系我们|网站条款|数码之家 ( 闽ICP备05031405号 )

GMT+8, 2019-9-22 09:56 , Processed in 0.209711 second(s), 16 queries , MemCache On.

Powered by Discuz!

© 2001-2019 Comsenz Inc.

快速回复 返回顶部 返回列表