老王USB电流电压表充电容量统计电流大小时间统计（开源）

面条数码 · 发表于 2019-9-6 21:54:23

今天闲下来了，有空写点东西。老王是谁？对，就是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    ---主程序：按键处理，定时器，看门狗

面条数码 · 发表于 2019-9-6 22:30:17

本帖最后由面条数码于 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

本帖最后由面条数码于 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

本帖最后由面条数码于 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

本帖最后由面条数码于 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

本帖最后由面条数码于 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那个能用吗？

y764930672 · 发表于 2019-9-7 08:52:11

技术贴，支持

2545889167 · 发表于 2019-9-7 11:29:00

辛苦了支持下

2545889167 · 发表于 2019-9-7 11:29:28

触景情伤发表于 2019-9-7 08:50
003f4那个能用吗？

内核都不一样

smzj10315655 · 发表于 2019-9-7 12:04:47

多谢楼主分享

liuhaob · 发表于 2019-9-7 14:33:58

支持楼主！

lifjt · 发表于 2019-9-7 17:25:15

关注过的，当时觉得取样电阻100毫欧好像有点大了点。

温力口 · 发表于 2019-9-7 17:35:30

谢谢分享。这帖子弄得我心痒痒的，看样子也要剁手败回来玩玩。。。。

触景情伤 · 发表于 2019-9-7 21:09:11

2545889167 发表于 2019-9-7 11:29
内核都不一样

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

2545889167 · 发表于 2019-9-7 21:12:40

触景情伤发表于 2019-9-7 21:09
我说的是那个hc003f4跟这个内核也不一样吗？

我以为你说stm8s003

411183343 · 发表于 2019-9-8 17:46:20

温力口发表于 2019-9-7 17:35
谢谢分享。这帖子弄得我心痒痒的，看样子也要剁手败回来玩玩。。。。

我鲁了俩，结果到手一个白屏，准备刷刷固件看看是不是漏刷了

871881392 · 发表于 2019-9-8 18:46:19

帮顶！:lol::lol::lol::lol::lol:

温力口 · 发表于 2019-9-9 06:38:36

请问这单片机用什么编译软件？谢谢。

账号		自动登录	找回密码
密码			立即注册

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

本帖子中包含更多资源

打赏

相关帖子

ST7565.h (显示程序)

ADC.h

FLASH.h

SYS.h

HC89F003.H

浏览过的版块

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