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", "keyscan.h": "c",
"uart.h": "c", "uart.h": "c",
"sensor_json.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; SDA = ack ? 0 : 1;
IIC_Delay (); IIC_Delay(); // 等待一段时间，确保电平稳定
SCL = 1; SCL = 1; // 拉高SCL线，允许数据传输
IIC_Delay (); IIC_Delay(); // 再次等待，确保时钟脉冲宽度
SCL = 0; SCL = 0; // 拉低SCL线，结束当前时钟周期
SDA = 1; // 释放SDA SDA = 1; // 释放SDA线，准备下一次通信
} }
/** /**

5
Driver/timer.c
View File

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

76
Src/main.c
View File

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