jxh/JYF_STC15W4K_wireless_charge
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

# V0.3 完成DHT10驱动函数，但是数据目前异常，等待排除硬件问题

Browse Source
This commit is contained in:
jxh
2025-03-21 00:45:04 +08:00
parent 58efe255f0
commit 9de7e3600d
9 changed files with 430 additions and 386 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.vscode/settings.json vendored
View File

@ -9,6 +9,7 @@
"keyscan.h": "c",
"uart.h": "c",
"sensor_json.h": "c",
"stdint.h": "c"
"stdint.h": "c",
"dht10.h": "c"
}
}

22
Driver/iic.c
View File

@ -92,15 +92,23 @@ IIC_WaitAck (void)
}
}
void
IIC_SendAck (bit ack)
/**
* @brief 发送IIC协议中的确认信号
*
* 该函数通过控制SDA（数据线）和SCL（时钟线）来发送确认（ACK）或不确认（NACK）信号。
* 在IIC通信中，发送方在传输数据后会发送一个ACK请求，接收方需要通过拉低或拉高SDA线来响应。
*
* @param ack 一个bit类型的变量，决定是否发送确认信号。ack为1时发送ACK，ack为0时发送NACK。
*/
void IIC_SendAck (bit ack)
{
// 根据ack参数决定SDA线的电平，1发送ACK，0发送NACK
SDA = ack ? 0 : 1;
IIC_Delay ();
SCL = 1;
IIC_Delay ();
SCL = 0;
SDA = 1; // 释放SDA
IIC_Delay(); // 等待一段时间，确保电平稳定
SCL = 1; // 拉高SCL线，允许数据传输
IIC_Delay(); // 再次等待，确保时钟脉冲宽度
SCL = 0; // 拉低SCL线，结束当前时钟周期
SDA = 1; // 释放SDA线，准备下一次通信
}
/**

5
Driver/timer.c
View File

@ -62,8 +62,9 @@ Timer4_Init (void)
void
Timer4_DelayUs (u16 us)
{
u32 cycles = us * (FOSC / 1000000); // 计算所需时钟周期数
u16 reload = 65536 - (cycles / 1); // 1T模式下无需分频
// u32 cycles = us * (FOSC / 1000000); // 计算所需时钟周期数
// 30000000/1000000=30
u16 reload = 65536 - (30 * us); // 1T模式下无需分频
T4H = reload >> 8; // 设置重载值高字节
T4L = reload & 0xFF; // 低字节

86
Lib/dht10.c
View File

@ -0,0 +1,86 @@
#include "dht10.h"
uint16_t dht10_data_temperature; // 温度 100 倍
uint16_t dht10_data_humidity; // 湿度 100 倍
void
DHT10_Init ()
{
DelayUs (1);
}
void
DHT10_ReadData ()
{
uint8_t i;
uint8_t buffer[6] = { 0 };
uint32_t hum_or_temp_raw;
// 发送启动测量命令
IIC_Start ();
IIC_SendByte (DHT10_ADDR << 1); // 发送设备地址+写
// 发送命令字节
IIC_SendByte (0xAC);
IIC_SendByte (0x33);
IIC_SendByte (0x00);
IIC_Stop ();
// 等待测量完成（DHT10需至少75ms）
DelayMs (80);
// 读取6字节数据
IIC_Start ();
IIC_SendByte ((DHT10_ADDR << 1) | 1);
for (i = 0; i < 6; i++)
{
buffer[i] = IIC_RecvByte ();
// 前5字节发送Ack，第6字节发送NAck
if (i < 5)
IIC_SendAck (1);
else
IIC_SendAck (0);
}
IIC_Stop ();
// 校验和：前5字节之和的低8位
i = buffer[0] + buffer[1] + buffer[2] + buffer[3] + buffer[4];
if (i != buffer[5])
{
return;
}
// 解析20位湿度数据（buffer[2]高4位为湿度数据）
hum_or_temp_raw = ((uint32_t)buffer[0] << 12) | ((uint32_t)buffer[1] << 4)
| (buffer[2] >> 4);
// 转换为实际值
// dht10_data->humidity = (float)hum_raw / 10.0f; // 湿度 实际值
dht10_data_humidity = (uint16_t)(hum_or_temp_raw * 10.0f); // 湿度 100倍
// 解析20位温度数据（buffer[5]高4位为温度数据）
hum_or_temp_raw = ((uint32_t)buffer[3] << 12) | ((uint32_t)buffer[4] << 4)
| (buffer[5] >> 4);
dht10_data_temperature
= (uint16_t)(hum_or_temp_raw * 10.0f) - 4000; // 温度 100倍
// dht10_data->temperature = (float)temp_raw / 10.0f - 40.0f; // 温度
// 实际值
return;
}
uint16_t
DHT10_GetTemperature ()
{
return dht10_data_temperature;
}
uint16_t
DHT10_GetHumidity ()
{
return dht10_data_humidity;
}

17
Lib/dht10.h
View File

@ -0,0 +1,17 @@
#ifndef __DHT10_H__
#define __DHT10_H__
#include <stdint.h>
#include "config.h"
#include "delay.h" // 确保有毫秒级延时函数
#include "iic.h" // 包含您的I2C驱动头文件
#define DHT10_ADDR 0x5C // I2C设备地址
void DHT10_Init ();
void DHT10_ReadData ();
uint16_t DHT10_GetTemperature ();
uint16_t DHT10_GetHumidity ();
#endif // __DHT10_H__

476
Lib/oled12864_drv.c
View File

@ -177,44 +177,44 @@ OLED_Coord (uint8_t X, uint8_t Y)
| 0x00); // 页面寻址模式下设置列开始地址寄存器的低位
}
/************************************************
函数名称 ： OLED_ShowRoll
功 能 ： OLED内置滚动显示
参 数 ： Y ---- 起始行
Line ---- 滚动行数 (0 ---> 取消滚动)
Mode ---- 滚动模式（OLED_LEFT_ROLL or OLED_RIGHT_ROLL）
返 回 值 ： 无
*************************************************/
void
OLED_ShowRoll (uint8_t Y, uint8_t Line, uint8_t Mode)
{
if (Line > 0)
{
if (Mode == OLED_LEFT_ROLL)
{
OLED_Write_Cmd (OLED_LEFT_ROLL); // 左滚动显示
}
else if (Mode == OLED_RIGHT_ROLL)
{
OLED_Write_Cmd (OLED_RIGHT_ROLL); // 右滚动显示
}
else
{
return;
}
OLED_Write_Cmd (0x00); // 虚拟字节设置，默认为0x00
OLED_Write_Cmd (Y); // 定义开始页面地址
OLED_Write_Cmd (0x07); // 帧频设置
OLED_Write_Cmd (Y + (Line - 1)); // 定义结束页面地址
OLED_Write_Cmd (0x00); // 虚拟字节设置，默认为0x00
OLED_Write_Cmd (0xFF); // 虚拟字节设置，默认为0xFF
OLED_Write_Cmd (0x2F); // 激活滚动
}
else
{
OLED_Write_Cmd (0x2E); // 失能滚动
}
}
// /************************************************
// 函数名称 ： OLED_ShowRoll
// 功 能 ： OLED内置滚动显示
// 参 数 ： Y ---- 起始行
// Line ---- 滚动行数 (0 ---> 取消滚动)
// Mode ---- 滚动模式（OLED_LEFT_ROLL or OLED_RIGHT_ROLL）
// 返 回 值 ： 无
// *************************************************/
// void
// OLED_ShowRoll (uint8_t Y, uint8_t Line, uint8_t Mode)
// {
// if (Line > 0)
// {
// if (Mode == OLED_LEFT_ROLL)
// {
// OLED_Write_Cmd (OLED_LEFT_ROLL); // 左滚动显示
// }
// else if (Mode == OLED_RIGHT_ROLL)
// {
// OLED_Write_Cmd (OLED_RIGHT_ROLL); // 右滚动显示
// }
// else
// {
// return;
// }
// OLED_Write_Cmd (0x00); // 虚拟字节设置，默认为0x00
// OLED_Write_Cmd (Y); // 定义开始页面地址
// OLED_Write_Cmd (0x07); // 帧频设置
// OLED_Write_Cmd (Y + (Line - 1)); // 定义结束页面地址
// OLED_Write_Cmd (0x00); // 虚拟字节设置，默认为0x00
// OLED_Write_Cmd (0xFF); // 虚拟字节设置，默认为0xFF
// OLED_Write_Cmd (0x2F); // 激活滚动
// }
// else
// {
// OLED_Write_Cmd (0x2E); // 失能滚动
// }
// }
/************************************************
函数名称 ： OLED_ShowChar
@ -417,101 +417,102 @@ OLED_ShowNum (uint8_t X, uint8_t Y, uint32_t Num, uint8_t Len, uint8_t Size,
}
}
/************************************************
函数名称 ： OLED_ShowHex
功 能 ： OLED十六进制显示
参 数 ： X ---- X轴
Y ---- Y轴
Num ---- 数字（10进制）
Size ---- 字体大小（固定宽度为 8像素）
Prefix ---- 补零显示使能
Inverse ---- 反白显示使能
返 回 值 ： 无
*************************************************/
void
OLED_ShowHex (uint8_t X, uint8_t Y, uint32_t Num, uint8_t Size, uint8_t Prefix,
uint8_t Inverse)
{
uint8_t t, temp;
uint8_t i = 0;
uint8_t show = 0;
// /************************************************
// 函数名称 ： OLED_ShowHex
// 功 能 ： OLED十六进制显示
// 参 数 ： X ---- X轴
// Y ---- Y轴
// Num ---- 数字（10进制）
// Size ---- 字体大小（固定宽度为 8像素）
// Prefix ---- 补零显示使能
// Inverse ---- 反白显示使能
// 返 回 值 ： 无
// *************************************************/
// void
// OLED_ShowHex (uint8_t X, uint8_t Y, uint32_t Num, uint8_t Size, uint8_t
// Prefix,
// uint8_t Inverse)
// {
// uint8_t t, temp;
// uint8_t i = 0;
// uint8_t show = 0;
for (t = 0; t < 4; t++)
{
temp = (uint8_t)(Num >> (12 - 4 * t)) & 0x000F; // 提取每位数字
// for (t = 0; t < 4; t++)
// {
// temp = (uint8_t)(Num >> (12 - 4 * t)) & 0x000F; // 提取每位数字
if (!show && t < 3)
{
if (0 == temp)
{
if (Prefix)
{
OLED_ShowChar (X + 8 * i, Y, '0', Size, Inverse);
i++;
}
continue;
}
else
{
show = 1;
}
}
switch (temp)
{
case 0:
temp = '0';
break;
case 1:
temp = '1';
break;
case 2:
temp = '2';
break;
case 3:
temp = '3';
break;
case 4:
temp = '4';
break;
case 5:
temp = '5';
break;
case 6:
temp = '6';
break;
case 7:
temp = '7';
break;
case 8:
temp = '8';
break;
case 9:
temp = '9';
break;
case 10:
temp = 'A';
break;
case 11:
temp = 'B';
break;
case 12:
temp = 'C';
break;
case 13:
temp = 'D';
break;
case 14:
temp = 'E';
break;
case 15:
temp = 'F';
break;
}
// if (!show && t < 3)
// {
// if (0 == temp)
// {
// if (Prefix)
// {
// OLED_ShowChar (X + 8 * i, Y, '0', Size, Inverse);
// i++;
// }
// continue;
// }
// else
// {
// show = 1;
// }
// }
// switch (temp)
// {
// case 0:
// temp = '0';
// break;
// case 1:
// temp = '1';
// break;
// case 2:
// temp = '2';
// break;
// case 3:
// temp = '3';
// break;
// case 4:
// temp = '4';
// break;
// case 5:
// temp = '5';
// break;
// case 6:
// temp = '6';
// break;
// case 7:
// temp = '7';
// break;
// case 8:
// temp = '8';
// break;
// case 9:
// temp = '9';
// break;
// case 10:
// temp = 'A';
// break;
// case 11:
// temp = 'B';
// break;
// case 12:
// temp = 'C';
// break;
// case 13:
// temp = 'D';
// break;
// case 14:
// temp = 'E';
// break;
// case 15:
// temp = 'F';
// break;
// }
OLED_ShowChar (X + 8 * i, Y, temp, Size, Inverse);
i++;
}
}
// OLED_ShowChar (X + 8 * i, Y, temp, Size, Inverse);
// i++;
// }
// }
/************************************************
函数名称 ： OLED_ShowFloat
@ -587,125 +588,130 @@ OLED_ShowFloat (uint8_t X, uint8_t Y, float Num, uint8_t Accuracy,
}
}
/************************************************
函数名称 ： OLED_ShowLanguage
功 能 ： OLED汉字显示(16x16) 不带字库的
参 数 ： X ---- X轴
Y ---- Y轴
pArray ---- 数据
Len ---- 字数长度
Inverse ---- 反白显示使能
返 回 值 ： 无
*************************************************/
// /************************************************
// 函数名称 ： OLED_ShowLanguage
// 功 能 ： OLED汉字显示(16x16) 不带字库的
// 参 数 ： X ---- X轴
// Y ---- Y轴
// pArray ---- 数据
// Len ---- 字数长度
// Inverse ---- 反白显示使能
// 返 回 值 ： 无
// *************************************************/
/*
mode 0:使用 1级指针来访问二维数组
mode 1:使用指向数组的指针来访问二维数组
*/
#define _OLED_ShowLanguage_MODE 0 // (0 or 1)
// /*
// mode 0:使用 1级指针来访问二维数组
// mode 1:使用指向数组的指针来访问二维数组
// */
// #define _OLED_ShowLanguage_MODE 0 // (0 or 1)
#if (0 == _OLED_ShowLanguage_MODE)
void
OLED_ShowLanguage (uint8_t X, uint8_t Y, const uint8_t *pArray, uint16_t Len,
uint8_t Inverse)
// #if (0 == _OLED_ShowLanguage_MODE)
// void
// OLED_ShowLanguage (uint8_t X, uint8_t Y, const uint8_t *pArray, uint16_t
// Len,
// uint8_t Inverse)
#elif (1 == _OLED_ShowLanguage_MODE)
void
OLED_ShowLanguage (uint8_t X, uint8_t Y, const uint8_t (*pArray)[16],
uint16_t Len, uint8_t Inverse)
// #elif (1 == _OLED_ShowLanguage_MODE)
// void
// OLED_ShowLanguage (uint8_t X, uint8_t Y, const uint8_t (*pArray)[16],
// uint16_t Len, uint8_t Inverse)
#endif /* _OLED_ShowLanguage_MODE */
{
uint8_t i, j;
uint8_t q = 0;
uint8_t temp = 0;
uint8_t distribute_flag = 0; // 文字平均分布标志
// #endif /* _OLED_ShowLanguage_MODE */
// {
// uint8_t i, j;
// uint8_t q = 0;
// uint8_t temp = 0;
// uint8_t distribute_flag = 0; // 文字平均分布标志
if (Len <= 8)
{
if (!X) // 首位显示，自动平均分布
{
switch (Len)
{
case 1:
temp = 56; // OLED_MAX_COLUMN / 2 - 8 = 56
break;
case 2:
temp
= 32; // (OLED_MAX_COLUMN - Len*16) / (Len + 1) = 32 Len = 2
break;
case 3:
temp = 20; // (OLED_MAX_COLUMN / 2 - 8) / 2 - 8 = 20
break;
case 4:
temp = 13; // (OLED_MAX_COLUMN - Len*16) / (Len + 1) = 12 .... 4
// Len = 4
break;
case 5:
temp = 8; // ((OLED_MAX_COLUMN / 2 - 8) - ((Len - 1) / 2)*16) /
// ((Len - 1) / 2 + 1) = 8 Len = 5
break;
case 6:
temp = 5; // (OLED_MAX_COLUMN - Len*16) / (Len + 1) = 4 .... 4
// Len = 6
break;
case 7:
temp = 2; // ((OLED_MAX_COLUMN / 2 - 8) / 2 - 8) / 2 - 8 = 2
break;
case 8:
temp = 0;
break;
default:
break;
}
X += temp;
distribute_flag = 1;
}
// if (Len <= 8)
// {
// if (!X) // 首位显示，自动平均分布
// {
// switch (Len)
// {
// case 1:
// temp = 56; // OLED_MAX_COLUMN / 2 - 8 = 56
// break;
// case 2:
// temp
// = 32; // (OLED_MAX_COLUMN - Len*16) / (Len + 1) = 32 Len
// = 2
// break;
// case 3:
// temp = 20; // (OLED_MAX_COLUMN / 2 - 8) / 2 - 8 = 20
// break;
// case 4:
// temp = 13; // (OLED_MAX_COLUMN - Len*16) / (Len + 1) = 12 ....
// 4
// // Len = 4
// break;
// case 5:
// temp = 8; // ((OLED_MAX_COLUMN / 2 - 8) - ((Len - 1) / 2)*16)
// /
// // ((Len - 1) / 2 + 1) = 8 Len = 5
// break;
// case 6:
// temp = 5; // (OLED_MAX_COLUMN - Len*16) / (Len + 1) = 4 .... 4
// // Len = 6
// break;
// case 7:
// temp = 2; // ((OLED_MAX_COLUMN / 2 - 8) / 2 - 8) / 2 - 8 = 2
// break;
// case 8:
// temp = 0;
// break;
// default:
// break;
// }
// X += temp;
// distribute_flag = 1;
// }
for (j = 0; j < Len; j++)
{
OLED_Coord (X, Y);
for (i = 0; i < 16; i++)
{
// for (j = 0; j < Len; j++)
// {
// OLED_Coord (X, Y);
// for (i = 0; i < 16; i++)
// {
#if (0 == _OLED_ShowLanguage_MODE)
OLED_Write_Data (*(pArray + 2 * j * 16 + i),
Inverse); // 前十六个数据
// #if (0 == _OLED_ShowLanguage_MODE)
// OLED_Write_Data (*(pArray + 2 * j * 16 + i),
// Inverse); // 前十六个数据
#elif (1 == _OLED_ShowLanguage_MODE)
OLED_Write_Data (pArray[2 * j][i], Inverse); // 前十六个数据
// #elif (1 == _OLED_ShowLanguage_MODE)
// OLED_Write_Data (pArray[2 * j][i], Inverse); // 前十六个数据
#endif /* _OLED_ShowLanguage_MODE */
}
// #endif /* _OLED_ShowLanguage_MODE */
// }
OLED_Coord (X, Y + 1);
for (i = 0; i < 16; i++)
{
// OLED_Coord (X, Y + 1);
// for (i = 0; i < 16; i++)
// {
#if (0 == _OLED_ShowLanguage_MODE)
OLED_Write_Data (*(pArray + 2 * j * 16 + 16 + i),
Inverse); // 后十六个数据
// #if (0 == _OLED_ShowLanguage_MODE)
// OLED_Write_Data (*(pArray + 2 * j * 16 + 16 + i),
// Inverse); // 后十六个数据
#elif (1 == _OLED_ShowLanguage_MODE)
OLED_Write_Data (pArray[2 * j + 1][i], Inverse); // 后十六个数据
// #elif (1 == _OLED_ShowLanguage_MODE)
// OLED_Write_Data (pArray[2 * j + 1][i], Inverse); //
// 后十六个数据
#endif /* _OLED_ShowLanguage_MODE */
}
X += (16 + temp);
// #endif /* _OLED_ShowLanguage_MODE */
// }
// X += (16 + temp);
if (distribute_flag)
{
q++;
// if (distribute_flag)
// {
// q++;
/* 特殊处理 */
if ((4 == Len && 2 == q) || (6 == Len && 0 == (q + 1) % 2))
{
X -= 1;
}
}
}
}
}
// /* 特殊处理 */
// if ((4 == Len && 2 == q) || (6 == Len && 0 == (q + 1) % 2))
// {
// X -= 1;
// }
// }
// }
// }
// }
/************************************************
函数名称 ： OLED_Display_On
@ -885,7 +891,7 @@ OLED_Draw_Font (uint8_t X, uint8_t Y, const uint8_t *pArray, uint8_t Inverse)
// for(i = 0;i < 16;i++)
// {
// OLED_Write_Data(*(buffer + 2*j*16 + i),
//Inverse); // 前十六个数据
// Inverse); // 前十六个数据
// }
// OLED_Coord(X, Y+1);
// for(i = 0;i < 16;i++)

30
Lib/oled12864_drv.h
View File

@ -47,7 +47,7 @@ void OLED_Write_Data (uint8_t Data, uint8_t Inverse);
void OLED_Fill (uint8_t Mode);
void OLED_Row_Clear (uint8_t Row, uint8_t Amount, uint8_t Mode);
void OLED_Coord (uint8_t X, uint8_t Y);
void OLED_ShowRoll (uint8_t Y, uint8_t Line, uint8_t Mode);
// void OLED_ShowRoll (uint8_t Y, uint8_t Line, uint8_t Mode);
void OLED_ShowChar (uint8_t X, uint8_t Y, uint8_t Char, uint8_t Size,
uint8_t Inverse);
void OLED_ShowString (uint8_t X, uint8_t Y, const uint8_t *pChar, uint16_t Len,
@ -57,25 +57,27 @@ void OLED_ShowPrintf (uint8_t X, uint8_t Y, const uint8_t *pChar, uint8_t Size,
uint32_t OLED_Power (uint8_t M, uint8_t N);
void OLED_ShowNum (uint8_t X, uint8_t Y, uint32_t Num, uint8_t Len,
uint8_t Size, uint8_t Prefix, uint8_t Inverse);
void OLED_ShowHex (uint8_t X, uint8_t Y, uint32_t Num, uint8_t Size,
uint8_t Prefix, uint8_t Inverse);
void OLED_ShowFloat (uint8_t X, uint8_t Y, float Num, uint8_t Accuracy,
uint8_t Size, uint8_t Inverse);
// void OLED_ShowHex (uint8_t X, uint8_t Y, uint32_t Num, uint8_t Size,
// uint8_t Prefix, uint8_t Inverse);
#if 1
void OLED_ShowLanguage (uint8_t X, uint8_t Y, const uint8_t *pChar,
uint16_t Len, uint8_t Inverse);
#else
void OLED_ShowLanguage (uint8_t X, uint8_t Y, const uint8_t (*pArray)[16],
uint16_t Len, uint8_t Inverse);
#endif
// #if 1
// void OLED_ShowLanguage (uint8_t X, uint8_t Y, const uint8_t *pChar,
// uint16_t Len, uint8_t Inverse);
// #else
// void OLED_ShowLanguage (uint8_t X, uint8_t Y, const uint8_t (*pArray)[16],
// uint16_t Len, uint8_t Inverse);
// #endif
void OLED_Display_On (void);
void OLED_Display_Off (void);
void OLED_Init (void);
void OLED_ShowChinese (uint8_t X, uint8_t Y, const uint8_t *pArray,
uint8_t Inverse);
void OLED_Draw_Font (uint8_t X, uint8_t Y, const uint8_t *pArray,
uint8_t Inverse);
// void OLED_ShowChinese (uint8_t X, uint8_t Y, const uint8_t *pArray,
// uint8_t Inverse);
// void OLED_Draw_Font (uint8_t X, uint8_t Y, const uint8_t *pArray,
// uint8_t Inverse);
#endif /* __OLED12864_DRV_H */

101
Lib/sensor_json.h
View File

@ -1,101 +0,0 @@
// /**********************************************
// * 文件名：sensor_json.h
// * 功能：将5个uint16参数封装为紧凑JSON格式
// * 特性：HEX传输、静态内存、无库依赖
// * 设计依据：C51硬件架构优化
// ​**********************************************/
// #ifndef __SENSOR_JSON_H__
// #define __SENSOR_JSON_H__
// #include <stdint.h>
// /* 硬件相关定义 */
// #define JSON_BUF_SIZE 57 // 内存预分配避免动态申请
// #define HEX_DIGITS "0123456789ABCDEF"
// /* 静态缓冲区声明 */
// static char json_buf[JSON_BUF_SIZE]
// = "{\"vol\":----,\"cur\":----,\"pwr\":----,\"tmp\":----,\"hum\":----}";
// /**********************************************
// * 函数名：hex4_encode
// * 功能：快速HEX转换（无分支优化）
// * 输入：16位数值、4字节输出缓冲区
// * 注：避免浮点运算提升执行效率
// ​**********************************************/
// static void
// hex4_encode (uint16_t num, char *out)
// {
// out[0] = HEX_DIGITS[(num >> 12) & 0x0F];
// out[1] = HEX_DIGITS[(num >> 8) & 0x0F];
// out[2] = HEX_DIGITS[(num >> 4) & 0x0F];
// out[3] = HEX_DIGITS[num & 0x0F];
// }
// /**********************************************
// * 主函数：make_sensor_json
// * 参数顺序：电压、电流、功率、温度、湿度
// * 返回值：静态缓冲区指针（注意不可重入）
// * 内存布局优化：固定位置替换减少计算量
// ​**********************************************/
// char *
// make_sensor_json (uint16_t v, uint16_t c, uint16_t p, uint16_t t, uint16_t h)
// {
// char tmp[4];
// /* 定点内存操作（避免字符串拼接） */
// hex4_encode (v, tmp);
// json_buf[7] = tmp[0];
// json_buf[8] = tmp[1]; // vol
// json_buf[9] = tmp[2];
// json_buf[10] = tmp[3];
// hex4_encode (c, tmp);
// json_buf[18] = tmp[0];
// json_buf[19] = tmp[1]; // cur
// json_buf[20] = tmp[2];
// json_buf[21] = tmp[3];
// hex4_encode (p, tmp);
// json_buf[29] = tmp[0];
// json_buf[30] = tmp[1]; // pwr
// json_buf[31] = tmp[2];
// json_buf[32] = tmp[3];
// hex4_encode (t, tmp);
// json_buf[40] = tmp[0];
// json_buf[41] = tmp[1]; // tmp
// json_buf[42] = tmp[2];
// json_buf[43] = tmp[3];
// hex4_encode (h, tmp);
// json_buf[51] = tmp[0];
// json_buf[52] = tmp[1]; // hum
// json_buf[53] = tmp[2];
// json_buf[54] = tmp[3];
// return json_buf;
// }
// #endif /* __SENSOR_JSON_H__ */
// /**********************************************
// * 使用示例：
// * #include "sensor_json.h"
// *
// * void main() {
// * char* data = make_sensor_json(
// * 0x0D0C, // 电压
// * 0x047E, // 电流
// * 0x1284, // 功率
// * 0x0CA2, // 温度
// * 0x0BF6 // 湿度
// * );
// * // 通过P1口输出（需按 配置端口模式）
// * for(uint8_t i=0; data[i]; i++) {
// * P1 = data[i]; // 假设P1接发送模块
// * delay_ms(1);
// * }
// * }
// ​**********************************************/

66
Src/main.c
View File

@ -11,12 +11,11 @@
// Lib
#include "delay.h"
#include "ina226.h"
#include "keyscan.h"
// #include "keyscan.h"
#include "dht10.h"
#include "oled12864_drv.h"
// #include "sensor_json.h"
char txBuffer[29]; // 固定长度发送缓冲区
void packData (uint16_t vol, uint16_t cur, uint16_t pwr, uint16_t tmp,
void packDataAndSent (uint16_t vol, uint16_t cur, uint16_t pwr, uint16_t tmp,
uint16_t hum); // 数据打包函数
void
@ -49,12 +48,24 @@ main ()
IIC_Init ();
OLED_Init ();
INA226_Init (0.005f, 2.0f);
DHT10_Init ();
// Key_Init ();
DelayMs (100); // 初始化延时
OLED_ShowPrintf (0, 0, "Hello, World!", OLED_FONT_EIGHT, OLED_LEFT_ROLL,
// OLED显示固定信息
OLED_ShowPrintf (0, 0, "Wireless Charge", OLED_FONT_SIXTEEN, OLED_LEFT_ROLL,
OLED_SHOW);
OLED_ShowPrintf (0, 2, "V", OLED_FONT_SIXTEEN, OLED_LEFT_ROLL, OLED_SHOW);
OLED_ShowPrintf (64, 2, "A", OLED_FONT_SIXTEEN, OLED_LEFT_ROLL, OLED_SHOW);
OLED_ShowPrintf (0, 4, "P", OLED_FONT_SIXTEEN, OLED_LEFT_ROLL, OLED_SHOW);
OLED_ShowPrintf (64, 4, "T", OLED_FONT_EIGHT, OLED_LEFT_ROLL, OLED_SHOW);
OLED_ShowPrintf (64, 5, "H", OLED_FONT_EIGHT, OLED_LEFT_ROLL, OLED_SHOW);
OLED_ShowPrintf (32, 3, ".", OLED_FONT_EIGHT, OLED_LEFT_ROLL, OLED_CLS);
OLED_ShowPrintf (96, 3, ".", OLED_FONT_EIGHT, OLED_LEFT_ROLL, OLED_CLS);
OLED_ShowPrintf (32, 5, ".", OLED_FONT_EIGHT, OLED_LEFT_ROLL, OLED_CLS);
OLED_ShowPrintf (96, 4, ".", OLED_FONT_EIGHT, OLED_LEFT_ROLL, OLED_CLS);
OLED_ShowPrintf (96, 5, ".", OLED_FONT_EIGHT, OLED_LEFT_ROLL, OLED_CLS);
P2M1 &= 0xFE; // P20为推挽输出
P2M0 |= 0x01;
@ -62,21 +73,33 @@ main ()
while (1)
{
OLED_ShowNum (0, 1, GetUpTime (), 10, OLED_FONT_EIGHT, OLED_LEFT_ROLL,
OLED_SHOW);
ina226_voltage = (int16_t)(INA226_ReadBusVoltage () * 100);
OLED_ShowNum (0, 2, ina226_voltage, 5, OLED_FONT_SIXTEEN, OLED_LEFT_ROLL,
OLED_SHOW);
OLED_ShowNum (16, 2, ina226_voltage / 100, 2, OLED_FONT_SIXTEEN,
OLED_LEFT_ROLL, OLED_CLS);
OLED_ShowNum (40, 2, ina226_voltage, 2, OLED_FONT_SIXTEEN,
OLED_LEFT_ROLL, OLED_CLS);
ina226_current = (int16_t)(INA226_ReadCurrent () * 100);
OLED_ShowNum (48, 2, ina226_current, 5, OLED_FONT_SIXTEEN,
OLED_LEFT_ROLL, OLED_SHOW);
OLED_ShowNum (80, 2, ina226_current / 100, 2, OLED_FONT_SIXTEEN,
OLED_LEFT_ROLL, OLED_CLS);
OLED_ShowNum (104, 2, ina226_current, 2, OLED_FONT_SIXTEEN,
OLED_LEFT_ROLL, OLED_CLS);
ina226_power = (int16_t)(INA226_ReadPower () * 100);
OLED_ShowNum (0, 4, ina226_power, 5, OLED_FONT_SIXTEEN, OLED_LEFT_ROLL,
OLED_SHOW);
OLED_ShowNum (16, 4, ina226_power / 100, 2, OLED_FONT_SIXTEEN,
OLED_LEFT_ROLL, OLED_CLS);
OLED_ShowNum (40, 4, ina226_power, 2, OLED_FONT_SIXTEEN, OLED_LEFT_ROLL,
OLED_CLS);
DHT10_ReadData ();
OLED_ShowNum (80, 4, DHT10_GetTemperature () / 100, 2, OLED_FONT_EIGHT,
OLED_LEFT_ROLL, OLED_CLS);
OLED_ShowNum (104, 4, DHT10_GetTemperature (), 2, OLED_FONT_EIGHT,
OLED_LEFT_ROLL, OLED_CLS);
OLED_ShowNum (80, 5, DHT10_GetHumidity () / 100, 2, OLED_FONT_EIGHT,
OLED_LEFT_ROLL, OLED_CLS);
OLED_ShowNum (104, 5, DHT10_GetHumidity (), 2, OLED_FONT_EIGHT,
OLED_LEFT_ROLL, OLED_CLS);
// DelayMs (100); // 初始化延时
// last_round_time = this_round_time;
@ -84,16 +107,12 @@ main ()
// OLED_ShowNum (4, 7, this_round_time - last_round_time, 3,
// OLED_FONT_EIGHT, OLED_LEFT_ROLL, OLED_SHOW);
packData (ina226_voltage, // 电压
packDataAndSent (ina226_voltage, // 电压
ina226_current, // 电流
ina226_power, // 功率
0x0CA2, // 温度
0x0BF6 // 湿度
);
printf (txBuffer); // 输出到串口
OLED_ShowPrintf (0, 6, p_json_str, OLED_FONT_EIGHT, OLED_LEFT_ROLL,
OLED_SHOW);
// Key_Scan ();
}
@ -101,10 +120,15 @@ main ()
// 数据打包函数
void
packData (uint16_t vol, uint16_t cur, uint16_t pwr, uint16_t tmp, uint16_t hum)
packDataAndSent (uint16_t vol, uint16_t cur, uint16_t pwr, uint16_t tmp,
uint16_t hum)
{
char txBuffer[29]; // 固定长度发送缓冲区
sprintf (txBuffer, "{%04X,%04X,%04X,%04X,%04X}\r\n", vol, cur, pwr, tmp,
hum); // 固定4字符HEX格式
printf (txBuffer); // 输出到串口
}
void