Boonlive_RD_Embedded/RS485_T1_Transition
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat:修改设备类型

Browse Source 
feat:修改为红外转发设备，将中弘网关协议转换为主机红外协议
This commit is contained in:
yeyangwen
2026-02-09 17:32:59 +08:00
parent 2285326a47
commit 5a726f7378
1421 changed files with 47158 additions and 21011 deletions
Download Patch File Download Diff File Expand all files Collapse all files

500
Source/SYSTEM/Bootload_fun.c Normal file
View File

@@ -0,0 +1,500 @@
/*
******************************************************************************
* @file Bootload.c
* @author caocong
* @version V1.00
* @date 2025/04/03
* @Description
* MCU空间规划
* Boot 0x0000 ~ 0x27FF 10K
* APP 0x2800 ~ 0xFEFF 53.8K
* APP_FEATURE 0xFF00 ~ 0xFFFF 256Byte
* EEPROM空间规划
* APP设备信息 0x10000000 - Size:0x40 - 64Byte
*
*/
#include "includes.h"
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
BOOT_INFO_T g_boot;
APP_FEATURE_INFO_T g_app_feature;
void Boot_Function_Init(void)
{
U8_T app_ready = 0;
U16_T sys_reset_sta = 0;
memset(&g_boot,0,sizeof(BOOT_INFO_T));
memset(&g_app_feature,0,sizeof(APP_FEATURE_INFO_T));
g_boot.ackValidity = 1000; //数据默认有效期为1000ms
EEPROM_Init();
/*读取APP 特征区*/
// app_ready = Check_APP_Feature();
//#if DBG_LOG_EN
// if(app_ready == 0x00)
// {
// Dbg_Println(DBG_BIT_SYS_STATUS,"APP Feature SUCC");
// Dbg_Println(DBG_BIT_SYS_STATUS,"APP app_flag:%d",g_app_feature.app_flag);
// Dbg_Println(DBG_BIT_SYS_STATUS,"APP app_start_addr:%08x",g_app_feature.app_start_addr);
// Dbg_Println(DBG_BIT_SYS_STATUS,"APP app_end_addr:%08x",g_app_feature.app_end_addr);
// Dbg_Println(DBG_BIT_SYS_STATUS,"APP app_crc_size:%d",g_app_feature.app_crc_size);
// Dbg_Println(DBG_BIT_SYS_STATUS,"APP app_crc_len:%d",g_app_feature.app_crc_len);
// Dbg_Print_Buff(DBG_BIT_SYS_STATUS,"APP app_crc:",g_app_feature.app_crc,g_app_feature.app_crc_len);
//
// }else {
// Dbg_Println(DBG_BIT_SYS_STATUS,"APP Feature Fail!");
//
// }
//#endif
sys_reset_sta = SYSCON->UREG3;
if(sys_reset_sta == 0x100) //软件复位 -- 升级开始复位源
{
g_boot.bootTimeout = 5000;
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS," Boot software reset");
#endif
}else if(sys_reset_sta == 0x01) //上电复位RPOR
{
g_boot.bootTimeout = 500;
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"Boot power on reset");
#endif
}else if(sys_reset_sta == 0x04) //外部手动复位
{
g_boot.bootTimeout = 2000;
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"Boot ex-pin reset");
#endif
}else if(sys_reset_sta == 0x10) //看门狗超时复位 --升级完成复位源
{
g_boot.bootTimeout = 2000;
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"Boot wdt reset");
#endif
}else if(sys_reset_sta == 0x40) //外部时钟无效复位
{
g_boot.bootTimeout = 2000;
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"Boot ex clock invalid reset");
#endif
}else if(sys_reset_sta == 0x80) //CPU请求复位 - link调试复位
{
g_boot.bootTimeout = 2000;
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"Boot cpu request reset");
#endif
}else
{
g_boot.bootTimeout = 2000;
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"Boot other reset 0x%x",sys_reset_sta);
#endif
}
}
U8_T Boot_Comm_CheckSum(U8_T * buffer, U16_T len)
{
U8_T sum = 0;
U16_T i=0;
while(len--)
{
sum += buffer[i];
i++;
}
return (~sum);
}
U16_T NetCRC16(U8_T * aStr, U16_T len)
{
U16_T xda , xdapoly ;
U16_T i, j, xdabit ;
xda = 0xFFFF ;
xdapoly = 0xA001 ; // (X**16 + X**15 + X**2 + 1)
for (i = 0; i < len; i++)
{
xda ^= aStr[i] ;
for (j = 0; j < 8; j++)
{
xdabit = (unsigned char)(xda & 0x01) ;
xda >>= 1 ;
if ( xdabit ) xda ^= xdapoly ;
}
}
return xda;
}
void Boot_Comm_FillReplyPack(BOOT_INFO_T *ack_uart)
{
U16_T data_len = ack_uart->ackLen + BCOMM_FMT_PARAM;
ack_uart->ackBuffer[BCOMM_FMT_TXAddr] = g_mcu_dev.dev_addr;
ack_uart->ackBuffer[BCOMM_FMT_SN] = ack_uart->sn;
ack_uart->ackBuffer[BCOMM_FMT_TYPE] = g_mcu_dev.dev_type;
ack_uart->ackBuffer[BCOMM_FMT_RXAddr] = g_boot.pc_addr;
ack_uart->ackBuffer[BCOMM_FMT_CMD] = ack_uart->cmd;
ack_uart->ackBuffer[BCOMM_FMT_LEN_L] = data_len & 0xFF;
ack_uart->ackBuffer[BCOMM_FMT_LEN_H] = (data_len >> 8) & 0xFF;
ack_uart->ackBuffer[BCOMM_FMT_CKS] = 0;
ack_uart->ackBuffer[BCOMM_FMT_CKS] = Boot_Comm_CheckSum(ack_uart->ackBuffer, data_len);
#if DBG_LOG_EN
Dbg_Print_Buff(DBG_BIT_SYS_STATUS,"ACKBuff ",ack_uart->ackBuffer,data_len);
#endif
//MCU485_SendData(ack_uart->ackBuffer, data_len);
Set_GroupSend(ack_uart->ackBuffer,data_len,0x01,ack_uart->ackValidity,100);
//ack_uart->ackLen = 0x00;
}
/*******************************************************************************
* Function Name : APP_Flash_AllEase
* Description : 擦除APP Flash空间
*******************************************************************************/
void APP_Flash_AllEase(void)
{
for(U32_T index = APP_Flash_StartAddr; index < APP_Flash_EndAddr;index+=APP_Flash_PageSize){
SYSCON_IWDCNT_Reload();
PageErase(index);
}
}
/*******************************************************************************
* Function Name : MCU_EEPROM_AllEase
* Description : 擦除EEPROM 空间
*******************************************************************************/
void MCU_EEPROM_AllEase(void)
{
for(U32_T index = MCU_EEPROM_StartAddr; index < MCU_EEPROM_EndAddr;index+=MCU_EEPROM_PageSize){
SYSCON_IWDCNT_Reload();
PageErase(index);
}
}
/*******************************************************************************
* Function Name : APP_FEATURE_Flash_Ease
* Description : 擦除APP特征区 Flash空间
*******************************************************************************/
void APP_FEATURE_Flash_Ease(void)
{
PageErase(APP_FEATURE_Flash_Addr);
}
/*******************************************************************************
* Function Name : Boot_Comm_UpgradeProcess
* Description : Boot通讯数据处理函数
*******************************************************************************/
U8_T Boot_Comm_UpgradeProcess(U8_T *data,U16_T len)
{
U8_T deal_flag = 0,group_flag = 0,reply_flag = 0,setinfo_flag = 0,crcResultFlag = 0;
U16_T data_len = 0,crcNumIndex = 0;
U32_T temp_data = 0,temp_data_2 = 0;
data_len = data[BCOMM_FMT_LEN_H];
data_len <<= 8;
data_len |= data[BCOMM_FMT_LEN_L];
if(len != data_len) {
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"Len Fail ");
#endif
return 0x01;
}
if(Boot_Comm_CheckSum(data,len) != 0) {
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"Boot_Comm_CheckSum Fail ");
#endif
return 0x02;
}
if( (data[BCOMM_FMT_SN] & 0x80) == 0x80){
//群发标志位
group_flag = 0x01;
if( (data[BCOMM_FMT_SN] & 0x0F) != g_boot.sn){
deal_flag = 0x01;
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"Group Data SN Disaffinity,Processing Data");
#endif
}else {
deal_flag = 0x00;
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"Group Data SN The Same,No Processing Data");
#endif
}
}else {
//单发标志位
group_flag = 0x00;
if( (data[BCOMM_FMT_SN] & 0x0F) != g_boot.sn){
//包序号不太相同，需要处理
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"Single Data SN Disaffinity,Processing Data");
#endif
deal_flag = 0x01;
reply_flag = 0x01;
}else if( (data[BCOMM_FMT_SN] & 0x40) == 0x40 ){
//包序号相同，重发标志位置位，不处理，但是需要回复数据,回复上次的数据内容
deal_flag = 0x00;
/*重发数据包命令与上一次的命令相同的话，直接回复上一次的数据内容*/
if(data[BCOMM_FMT_CMD] == g_boot.ackBuffer[BCOMM_FMT_CMD] ){
reply_flag = 0x01;
}
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"Single Data SN The Same,No Processing Data");
#endif
}
}
/*判断类型是否相同，且不是广播类型*/
if( (data[BCOMM_FMT_TYPE] != g_mcu_dev.dev_type) && (data[BCOMM_FMT_TYPE] != 0xFF) ){
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"Boot_Comm_RecvType %d - %d ",g_mcu_dev.dev_type,data[BCOMM_FMT_TYPE]);
#endif
return 0x03;
}
/*判断是否广播类型与广播地址*/
if( (data[BCOMM_FMT_RXAddr] != g_mcu_dev.dev_addr) && (data[BCOMM_FMT_RXAddr] != 0xFF) ){
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"Boot_Comm_RecvAddr %d - %d ",g_mcu_dev.dev_addr,data[BCOMM_FMT_RXAddr]);
#endif
return 0x04;
}
Boot_Time_Refresh();
g_boot.pc_addr = data[BCOMM_FMT_TXAddr];
g_boot.sn = data[BCOMM_FMT_SN] & 0x0F;
g_boot.cmd = data[BCOMM_FMT_CMD];
switch(g_boot.cmd){
case BCOMM_CMD_Handshake: //握手命令
if( (deal_flag == 0x01) && (data_len >= (BCOMM_FMT_PARAM + 4) ) ){
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"BCOMM_CMD_Handshake Proecessing ");
#endif
/*设置Boot 超时时间*/
temp_data = data[BCOMM_FMT_PARAM + 1];
temp_data <<= 8;
temp_data |= data[BCOMM_FMT_PARAM];
if(temp_data != g_boot.bootTimeout){
g_boot.bootTimeout = temp_data;
if(g_boot.bootTimeout < 10) g_boot.bootTimeout = 10;
g_boot.bootTimeout = g_boot.bootTimeout * 1000;
}
/*回复数据的有效期*/
temp_data = data[BCOMM_FMT_PARAM + 3];
temp_data <<= 8;
temp_data |= data[BCOMM_FMT_PARAM + 2];
g_boot.ackValidity = temp_data;
}
//握手命令 - 需要回复的数据，正常回复
if(reply_flag != 0x01) break; //不回复，直接退出
g_boot.ackBuffer[BCOMM_FMT_PARAM] = Project_Area; //当前处于Bootload区域 0x01：Boot;0x02：APP
g_boot.ackBuffer[BCOMM_FMT_PARAM + 1] = g_mcu_dev.dev_boot_ver; //Boot 软件版本号
g_boot.ackBuffer[BCOMM_FMT_PARAM + 2] = g_mcu_dev.dev_app_ver; //APP 软件版本号
//MCU UID
g_boot.ackBuffer[BCOMM_FMT_PARAM + 3] = 0x03; //UUID 长度 MD203 UID 3Byte
g_boot.ackBuffer[BCOMM_FMT_PARAM + 4] = SYSCON->UID0;
g_boot.ackBuffer[BCOMM_FMT_PARAM + 5] = SYSCON->UID1;
g_boot.ackBuffer[BCOMM_FMT_PARAM + 6] = SYSCON->UID2;
//机型编号 - 32Byte 最长32Byte
if(g_mcu_dev.dev_name_len > EEPROM_DEV_NAME_Size) g_mcu_dev.dev_name_len = EEPROM_DEV_NAME_Size;
g_boot.ackBuffer[BCOMM_FMT_PARAM + 7] = g_mcu_dev.dev_name_len;
for(U8_T i=0;i<EEPROM_DEV_NAME_Size;i++){
g_boot.ackBuffer[BCOMM_FMT_PARAM + i + 8] = g_mcu_dev.dev_name[i];
}
g_boot.ackLen = 0x08 + EEPROM_DEV_NAME_Size;
break;
case BCOMM_CMD_Jump: //跳转命令 //boot
if(deal_flag != 0x01) break; //不处理直接退出
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"BCOMM_CMD_Jump Proecessing ");
#endif
if(data[BCOMM_FMT_PARAM] == 0x01){
/*跳转至APP区域*/
BUS485_Jump_Boot(0x01);
g_boot.ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplySUCC;
}else {
/*参数错误*/
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"ERR:Jump_boot");
#endif
g_boot.ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplyFAIL;
}
g_boot.ackLen = 1;
break;
default: //未知命令
g_boot.ackBuffer[BCOMM_FMT_PARAM] = BCOMM_CMD_ReplyFAIL;
g_boot.ackLen = 1;
break;
}
/*回复通讯数据*/
if( (group_flag == 0x00) && (reply_flag == 0x01) )
{
Boot_Comm_FillReplyPack(&g_boot);
}
}
void Boot_Time_Refresh(void)
{
g_boot.bootTick = SysTick_1ms;
}
void Boot_TimeOut_Task(void)
{
if(SysTick_1ms - g_boot.bootTick >= g_boot.bootTimeout)
{
while(1); //执行看门狗复位
}
}
void Jump_To_APP(void)
{
volatile U32_T EIPaddr = g_app_feature.app_start_addr + 0x010C;
asm("mov r0,%0\n"::"r"(EIPaddr):); // APP入口地址 __start label的值
asm(" jmp r0 ");
}
U8_T Check_APP_Feature(void)
{
U8_T temp_buff[530];
U16_T crcNumIndex = 0,temp_data = 0,temp_data_2 = 0;
U32_T crc_data_len = 0,crc_feature_len = 0;
/*读取APP 特征区*/
ReadDataArry_U8(APP_FEATURE_Flash_Addr,sizeof(APP_FEATURE_INFO_T),temp_buff);
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"App Feature Size:%d",sizeof(APP_FEATURE_INFO_T));
Dbg_Print_Buff(DBG_BIT_SYS_STATUS,"App Feature Buff:",temp_buff,sizeof(APP_FEATURE_INFO_T));
#endif
crc_data_len = temp_buff[1];
crc_data_len <<= 8;
crc_data_len |= temp_buff[0];
temp_buff[0] = 0x00;
temp_buff[1] = 0x00;
if( NetCRC16((U8_T *)temp_buff,sizeof(APP_FEATURE_INFO_T)) != crc_data_len )
{
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"App Feature CRC ERROR");
#endif
return 0x01;
}
memcpy(&g_app_feature,temp_buff,sizeof(APP_FEATURE_INFO_T));
g_app_feature.crcL_check = crc_data_len & 0xFF;
g_app_feature.crcH_check = (crc_data_len >> 8) & 0xFF;
if(g_app_feature.app_flag != App_Procedure_Ready)
{
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"App Feature Flag ERROR");
#endif
return 0x02; //没有APP标志位
}
if( (g_app_feature.app_start_addr >= APP_Flash_StartAddr)
&& (g_app_feature.app_end_addr < APP_Flash_EndAddr)
&& (g_app_feature.app_end_addr > g_app_feature.app_start_addr)
&& (g_app_feature.app_crc_size == 512) )
{
crc_data_len = g_app_feature.app_end_addr - g_app_feature.app_start_addr;
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"App Len :%d ",crc_data_len);
#endif
if( (crc_data_len % g_app_feature.app_crc_size ) != 0x00 ){
crc_feature_len = ((crc_data_len / g_app_feature.app_crc_size) + 1) * 2;
}else {
crc_feature_len = (crc_data_len / g_app_feature.app_crc_size) * 2;
}
if(g_app_feature.app_crc_len != crc_feature_len) {
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"App CRC Len :%d - %d",crc_feature_len,g_app_feature.app_crc_len);
#endif
return 0x03; //APP CRC长度不对
}
for(U32_T crc_addr = g_app_feature.app_start_addr; crc_addr < g_app_feature.app_end_addr;crc_addr += g_app_feature.app_crc_size)
{
SYSCON_IWDCNT_Reload();
if( g_app_feature.app_end_addr - crc_addr >= g_app_feature.app_crc_size) {
crc_data_len = g_app_feature.app_crc_size;
}else {
crc_data_len = g_app_feature.app_end_addr - crc_addr;
}
ReadDataArry_U8(crc_addr,crc_data_len,temp_buff);
temp_data = NetCRC16(temp_buff,crc_data_len);
temp_data_2 = g_app_feature.app_crc[crcNumIndex + 1];
temp_data_2 <<= 8;
temp_data_2 |= g_app_feature.app_crc[crcNumIndex];
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"App CRC ADDR:%08x %04x-%04x",crc_addr,temp_data,temp_data_2);
#endif
if(temp_data != temp_data_2){
/*校验失败 - */
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"App CRC Fail ADDR:%08X %04X-%04X",crc_addr,temp_data,temp_data_2);
#endif
return 0x04; //校验失败
}
crcNumIndex += 2;
}
}else {
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"App Feature StartAddr ERROR");
Dbg_Println(DBG_BIT_SYS_STATUS,"APP app_start_addr:%08x",g_app_feature.app_start_addr);
Dbg_Println(DBG_BIT_SYS_STATUS,"APP app_end_addr:%08x",g_app_feature.app_end_addr);
Dbg_Println(DBG_BIT_SYS_STATUS,"APP app_crc_len:%d",g_app_feature.app_crc_len);
#endif
return 0x05; //起始地址不正确
}
return 0x00;
}

105
Source/SYSTEM/dip_switch.c Normal file
View File

@@ -0,0 +1,105 @@
#include "includes.h"
DIP_t g_Dip;
void DIP_Switch_Init(void){
GPIO_Init(GPIOB0,0,Intput);
GPIO_Init(GPIOB0,1,Intput);
GPIO_Init(GPIOB0,2,Intput);
GPIO_PullHigh_Init(GPIOB0,0);
GPIO_PullHigh_Init(GPIOB0,1);
GPIO_PullHigh_Init(GPIOB0,2);
memset(&g_Dip,0,sizeof(DIP_t));
delay_nms(20);
/*上电读取拨码状态*/
for (U8_T i = 0; i < DIP_CHN_MAX; i++) {
if(DIP_GetSwitchState(i) == DIP_PRESS){
g_Dip.DIP_val |= DIP_VAL_ON << i;
}
}
g_Dip.DIP_last_val = g_Dip.DIP_val;
g_Dip.DIP_addr = g_Dip.DIP_val & 0x07;
/*进入设置界面 - 先决条件*/
Dbg_Println(DBG_BIT_SYS_STATUS,"DIP Addr:%d",g_Dip.DIP_val);
}
U8_T DIP_GetSwitchState(U8_T i){
U8_T val = 0;
switch (i)
{
case DIP_CH1:
val = GPIO_Read_Status(GPIOB0,2);
break;
case DIP_CH2:
val = GPIO_Read_Status(GPIOB0,1);
break;
case DIP_CH3:
val = GPIO_Read_Status(GPIOB0,0);
break;
}
return val;
}
void DIP_ScanTask(void)
{
static U32_T update_20ms = 0;
if (SysTick_1ms - update_20ms > DIP_SCAN_Time)
{
update_20ms = SysTick_1ms;
for (U8_T i = 0; i < DIP_CHN_MAX; i++)
{
if (DIP_GetSwitchState(i) == DIP_PRESS)
{
g_Dip.delayCnt_OFF[i] = 0;
if (g_Dip.delayCnt_ON[i] < DIP_DELAY_COUNT)
{
g_Dip.delayCnt_ON[i]++;
}
else
{
g_Dip.DIP_val |= (DIP_VAL_ON << i);
g_Dip.delayCnt_ON[i] = 0;
}
}
else
{
g_Dip.delayCnt_ON[i] = 0;
if (g_Dip.delayCnt_OFF[i] < DIP_DELAY_COUNT)
{
g_Dip.delayCnt_OFF[i]++;
}
else
{
g_Dip.DIP_val &= ~(DIP_VAL_ON << i);
g_Dip.delayCnt_OFF[i] = 0;
}
}
}
}
if(g_Dip.DIP_val != g_Dip.DIP_last_val)
{
g_Dip.DIP_last_val = g_Dip.DIP_val;
/*拨码开关 - Bit0~Bit3：设备地址*/
g_Dip.DIP_addr = g_Dip.DIP_val & 0x07;
Dbg_Println(DBG_BIT_SYS_STATUS,"DIP Change Addr:%d",g_Dip.DIP_addr);
}
}

336
Source/SYSTEM/eeprom.c Normal file
View File

@@ -0,0 +1,336 @@
#include "includes.h"
E_PARA_INFO g_eeprom;
E_MCU_DEV_INFO g_mcu_dev;
U8_T EEPROM_CheckSum(U8_T *data,U16_T len)
{
U8_T data_sum = 0;
for(U16_T i = 0;i<len;i++)
{
data_sum += data[i];
}
return data_sum;
}
void EEPROM_Init(void){
U8_T rev = 0;
EnIFCClk; //使能 IFC 时钟
IFC->MR |= 0x10002; //高速模式，延迟 2 个周期
delay_nms(10);
memset(&g_eeprom,0,sizeof(E_PARA_INFO));
rev = EEPROM_ReadParaInfo(&g_eeprom);
if(rev == 0x00){
//读取成功，开始校验以下参数
EEPROM_Validate_ParaInfo(&g_eeprom);
}else{
//读取失败，恢复默认参数
EEPROM_Default_ParaInfo(&g_eeprom);
Dbg_Println(DBG_BIT_SYS_STATUS,"Para Info Use Default:%d",g_eeprom.pipe_flag);
}
}
U8_T EEPROM_ReadParaInfo(E_PARA_INFO *info){
U8_T read_info[6];
U8_T para_data[EEPROM_APP_DATA_Size_Max];
U16_T read_len = 0;
memset(read_info,0,sizeof(read_info));
memset(para_data,0,sizeof(para_data));
ReadDataArry_U8(EEPROM_ParaInfo_Address,4,read_info);
if(read_info[0] == EEPROM_APP_SVAE_FLAG){
read_len = read_info[2];
read_len <<= 8;
read_len |= read_info[1];
if(read_len <= EEPROM_APP_DATA_Size_Max){
ReadDataArry_U8(EEPROM_ParaInfo_Address+EEPROM_Offset_Data,read_len,para_data);
if(EEPROM_CheckSum(para_data,sizeof(E_PARA_INFO)) == read_info[3]){
//校验成功
memcpy((uint8_t *)info,para_data,sizeof(E_PARA_INFO));
return 0x00;
}
}
}
return 0x01;
}
U8_T EEPROM_WriteParaInfo(E_PARA_INFO *info){
U8_T save_data[EEPROM_APP_DATA_Size_Max + 6];
U16_T save_len = sizeof(E_PARA_INFO);
if(save_len >= EEPROM_APP_DATA_Size_Max) save_len = EEPROM_APP_DATA_Size_Max;
save_data[0] = EEPROM_APP_SVAE_FLAG;
save_data[1] = save_len & 0xFF;
save_data[2] = (save_len >> 8) & 0xFF;
memcpy(&save_data[4],(uint8_t *)info,save_len);
save_data[3] = EEPROM_CheckSum(&save_data[4],save_len);
save_len+=4;
Page_ProgramData(EEPROM_ParaInfo_Address,save_len,save_data);
return 0;
}
U8_T EEPROM_ClearParaInfo(void){
U8_T save_data[EEPROM_APP_DATA_Size_Max+10];
UINT16 save_len = sizeof(E_PARA_INFO);
if(save_len >= EEPROM_APP_DATA_Size_Max) save_len = EEPROM_APP_DATA_Size_Max;
save_len += 4;
memset(save_data,0xFF,save_len);
Page_ProgramData(EEPROM_ParaInfo_Address,save_len,save_data);
return 0;
}
U8_T EEPROM_Validate_ParaInfo(E_PARA_INFO *info){
U8_T i=0;
//以下为本地参数
// //温差
// if(info->temp_diff > 18 ){
// info->temp_diff = EEPROM_TempDifference_Default; //默认
// }
// Dbg_Println(DBG_BIT_SYS_STATUS,"Para Info temp_diff %d",info->temp_diff);
//
// //温度显示单位
// if(info->temp_select > 0x02 ){
// info->temp_select = EEPROM_TempSelect_Default; //默认保护电流为10A
// }
//
//
// if(info->backlight_en >= 0x02)
// {
// info->backlight_en = 0x00;
// }
//
// if(info->pipe_flag > 0x02)
// {
// info->pipe_flag = 0x00;
// }
//
// if((info->dev_addr == 0x00) || (info->dev_addr == 0xff))
// {
// info->dev_addr = 0x01;
// }
//
// //按键灵敏度
// if(info->key_sens_level > 2)
// {
// info->key_sens_level = EEPROM_TouchLevel_Default; //默认中灵敏度
// }
//
// //显示语言
// if(info->langue_select > 2)
// {
// info->langue_select = EEPROM_LangueSelect_Default;//默认中英文混合
// }
//设备端口类型
if(info->dev_port > 2) //2024-12-16
{
info->dev_port = POLLING_PORT; //默认轮训端口
}
Dbg_Println(DBG_BIT_SYS_STATUS,"Para Info temp unit:%d backlight_en:%d key_sens_level:%d device_addr:%d device_port:%d",\
info->temp_select,info->backlight_en,info->key_sens_level,info->dev_addr,info->dev_port);
return 0;
}
/*恢复默认值*/
void EEPROM_Default_ParaInfo(E_PARA_INFO *info){
info->dev_addr = 0x01;
info->pipe_flag = 0x00;
info->temp_diff = EEPROM_TempDifference_Default;
info->temp_select = EEPROM_TempSelect_Default;
info->backlight_en = 0x00;
info->key_sens_level = EEPROM_TouchLevel_Default;
info->langue_select = EEPROM_LangueSelect_Default;
info->dev_port = POLLING_PORT; //2024-12-16
}
/*************<- boot ->****************/
/*******************************************************************************
* Function Name : EEPROM_ReadMCUDevInfo
* Description : 从EEPROM中读取设备信息
*******************************************************************************/
U8_T EEPROM_ReadMCUDevInfo(E_MCU_DEV_INFO *info)
{
U8_T read_info[6];
U8_T para_data[EEPROM_DATA_Size_Max];
U16_T read_len = 0;
memset(read_info,0,sizeof(read_info));
memset(para_data,0,sizeof(para_data));
ReadDataArry_U8(EEPROM_MCUDevInfo_Address,4,read_info);
if(read_info[0] == EEPROM_SVAE_FLAG){
read_len = read_info[2];
read_len <<= 8;
read_len |= read_info[1];
if(read_len <= EEPROM_DATA_Size_Max){
ReadDataArry_U8(EEPROM_MCUDevInfo_Address+EEPROM_Offset_Data,read_len,para_data);
if(EEPROM_CheckSum(para_data,sizeof(E_MCU_DEV_INFO)) == read_info[3]){
//校验成功
memcpy((uint8_t *)info,para_data,sizeof(E_MCU_DEV_INFO));
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS,"EE DevAddr:%d",g_mcu_dev.dev_addr);
Dbg_Println(DBG_BIT_SYS_STATUS,"EE DevType:%d",g_mcu_dev.dev_type);
Dbg_Println(DBG_BIT_SYS_STATUS,"EE DevBootVer:%d",g_mcu_dev.dev_boot_ver);
Dbg_Println(DBG_BIT_SYS_STATUS,"EE DevAppVer:%d",g_mcu_dev.dev_app_ver);
Dbg_Println(DBG_BIT_SYS_STATUS,"EE DevNameLen:%d",g_mcu_dev.dev_name_len);
Dbg_Println(DBG_BIT_SYS_STATUS,"EE DevName:%s",g_mcu_dev.dev_name);
#endif
return 0x00;
}
}
}
return 0x01;
}
/*******************************************************************************
* Function Name : EEPROM_WriteMCUDevInfo
* Description : 将设备信息写入到EEPROM中
*******************************************************************************/
U8_T EEPROM_WriteMCUDevInfo(E_MCU_DEV_INFO *info)
{
U8_T save_data[EEPROM_DATA_Size_Max + 6];
U16_T save_len = sizeof(E_MCU_DEV_INFO);
if(save_len >= EEPROM_DATA_Size_Max) save_len = EEPROM_DATA_Size_Max;
save_data[0] = EEPROM_SVAE_FLAG;
save_data[1] = save_len & 0xFF;
save_data[2] = (save_len >> 8) & 0xFF;
memcpy(&save_data[4],(uint8_t *)info,save_len);
save_data[3] = EEPROM_CheckSum(&save_data[4],save_len);
save_len+=4;
Page_ProgramData(EEPROM_MCUDevInfo_Address,save_len,save_data);
return 0;
}
/*******************************************************************************
* Function Name : EEPROM_Default_MCUDevInfo
* Description : EEPROM中参数恢复默认值，且将默认参数保存至EEPROM中
*******************************************************************************/
void EEPROM_Default_MCUDevInfo(E_MCU_DEV_INFO *info)
{
#if (Project_Area == 0x01)
/*Boot 区域*/
info->dev_addr = 0x00;
info->dev_type = 0x00;
info->dev_app_ver = 0x00;
info->dev_boot_ver = Project_FW_Version;
info->dev_name_len = sizeof(Peoject_Name);
memset((char *)info->dev_name,0,EEPROM_DEV_NAME_Size);
memcpy((char *)info->dev_name,(char *)Peoject_Name,info->dev_name_len);
EEPROM_WriteMCUDevInfo(info);
#elif (Project_Area == 0x02)
/*APP 区域*/
info->dev_addr = 0x01;
info->dev_type = Project_Type;
info->dev_app_ver = Project_FW_Version;
info->dev_name_len = sizeof(Peoject_Name);
memset((char *)info->dev_name,0,EEPROM_DEV_NAME_Size);
memcpy((char *)info->dev_name,(char *)Peoject_Name,info->dev_name_len);
EEPROM_WriteMCUDevInfo(info);
#endif
}
/*******************************************************************************
* Function Name : EEPROM_Validate_MCUDevInfo
* Description : 校验从EEPROM 中读取的参数是否正确，如果不正确的话，便将当前正确的参数写入
APP区域中，判断APP参数与EEPROM中记录的是否一致
Boot区域中，判断Boot参数与EEPROM中记录的是否一致
*******************************************************************************/
void EEPROM_Validate_MCUDevInfo(E_MCU_DEV_INFO *info)
{
#if (Project_Area == 0x01)
/*Boot 区域*/
U8_T save_flag = 0;
if(info->dev_boot_ver != Project_FW_Version)
{
info->dev_boot_ver = Project_FW_Version;
save_flag = 0x01;
}
if(save_flag == 0x01)
{
EEPROM_WriteMCUDevInfo(info);
}
#elif (Project_Area == 0x02)
/*APP 区域*/
U8_T save_flag = 0;
if(info->dev_app_ver != Project_FW_Version)
{
info->dev_app_ver = Project_FW_Version;
save_flag = 0x01;
}
if(info->dev_type != Project_Type)
{
info->dev_type = Project_Type;
save_flag = 0x01;
}
if(info->dev_name_len != sizeof(Peoject_Name))
{
info->dev_name_len = sizeof(Peoject_Name);
save_flag = 0x01;
}
if(strncmp((char *)info->dev_name,(char *)Peoject_Name,sizeof(Peoject_Name)))
{
memcpy((char *)info->dev_name,(char *)Peoject_Name,info->dev_name_len);
save_flag = 0x01;
}
if(save_flag == 0x01)
{
EEPROM_WriteMCUDevInfo(info);
}
#endif
}

88
Source/SYSTEM/inc/Bootload_fun.h Normal file
View File

@@ -0,0 +1,88 @@
#ifndef _BOOTLOAD_FUNCTION_H_
#define _BOOTLOAD_FUNCTION_H_
#include "apt32f102.h"
#include "apt32f102_ifc.h"
#include "apt32f102_syscon.h"
#include "uart.h"
#define App_Procedure_Ready 0x66 //APP准备就绪标志位
#define APP_Flash_PageSize 0x100
#if DBG_LOG_EN
#define APP_Flash_StartAddr PROM_PageAdd96 //调试APP起始地址
#else
#define APP_Flash_StartAddr PROM_PageAdd40
#endif
#define APP_Flash_EndAddr PROM_PageAdd255
#define APP_FEATURE_Flash_Addr PROM_PageAdd255
#define MCU_EEPROM_PageSize 0x40
#define MCU_EEPROM_StartAddr DROM_PageAdd0
#define MCU_EEPROM_EndAddr (DROM_PageAdd31 + MCU_EEPROM_PageSize)
#define BCOMM_CMD_Handshake 0xC0
#define BCOMM_CMD_Jump 0xC1
#define BCOMM_CMD_SetInfo 0xC2
#define BCOMM_CMD_WriteFlash 0xC3
#define BCOMM_CMD_ReadFlash 0xC4
#define BCOMM_CMD_EraseFlash 0xC5
#define BCOMM_CMD_WriteEEPROM 0xC6
#define BCOMM_CMD_ReadEEPROM 0xC7
#define BCOMM_CMD_EraseEEPROM 0xC8
#define BCOMM_CMD_CheckData 0xC9
#define BCOMM_CMD_ReplySUCC 0x00
#define BCOMM_CMD_ReplyFAIL 0x01
#define BCOMM_ACKSize 300
#define BCOMM_ParaSize 280
typedef enum
{
BCOMM_FMT_TXAddr,
BCOMM_FMT_SN,
BCOMM_FMT_TYPE,
BCOMM_FMT_RXAddr,
BCOMM_FMT_LEN_L,
BCOMM_FMT_LEN_H,
BCOMM_FMT_CKS,
BCOMM_FMT_CMD,
BCOMM_FMT_PARAM,
}BOOT_COMM_FMT_e;
typedef struct{
U8_T jump_start;
U8_T sn;
U8_T cmd;
U8_T pc_addr;
U8_T ackBuffer[BCOMM_ACKSize];
U16_T ackLen;
U16_T ackValidity; //数据回复有效期
U32_T bootTimeout;
U32_T bootTick;
}BOOT_INFO_T;
typedef struct{
U8_T crcL_check;
U8_T crcH_check;
U8_T app_flag;
U8_T app_crc[241];
U16_T app_crc_size;
U16_T app_crc_len;
U32_T app_start_addr;
U32_T app_end_addr;
}APP_FEATURE_INFO_T; /*字节空间是256Byte*/
extern BOOT_INFO_T g_boot;
void Boot_Function_Init(void);
U8_T Boot_Comm_UpgradeProcess(U8_T *data,U16_T len);
void Boot_Time_Refresh(void);
void Boot_TimeOut_Task(void);
void Jump_To_APP(void);
U8_T Check_APP_Feature(void);
#endif

42
Source/SYSTEM/inc/dip_switch.h Normal file
View File

@@ -0,0 +1,42 @@
#ifndef _DIP_SWITCH_H_
#define _DIP_SWITCH_H_
#include "apt32f102.h"
#include "apt32f102_gpio.h"
#define DIP_PRESS 0x00 //按键按下为低
#define DIP_LOOSEN 0x01 //按键松开为高
#define DIP_DELAY_COUNT 5 //扫描次数
#define DIP_SCAN_Time 20 //每次扫描时间
typedef enum
{
DIP_CH1,
DIP_CH2,
DIP_CH3,
DIP_CHN_MAX,
}DIP_CHN_e;
typedef enum
{
DIP_VAL_OFF, //松开
DIP_VAL_ON, //按下
}DIP_VAL_e;
typedef struct
{
U8_T delayCnt_ON[DIP_CHN_MAX];
U8_T delayCnt_OFF[DIP_CHN_MAX];
U8_T DIP_addr; //设备地址
U32_T DIP_val;
U32_T DIP_last_val;
}DIP_t;
extern DIP_t g_Dip;
void DIP_Switch_Init(void);
uint8_t DIP_GetSwitchState(uint8_t i);
void DIP_ScanTask(void);
#endif

93
Source/SYSTEM/inc/eeprom.h Normal file
View File

@@ -0,0 +1,93 @@
#ifndef _EEPROM_H_
#define _EEPROM_H_
#include "apt32f102.h"
/*地址范围：0x10000000~0x100007FF，DROM 每页64BYTE，按页分配*/
#define EEPROM_MCUDevInfo_Address 0x10000000 //MCU 设备信息地址固定为0x10000000，大小为0x40 此区域不可改动
/*APP*/
#define EEPROM_ParaInfo_Address 0x10000100
#define EEPROM_TOUCHPARA1_SaveAddr 0x10000200
#define EEPROM_TOUCHPARA2_SaveAddr 0x10000280
#define EEPROM_TOUCHPARA3_SaveAddr 0x10000300
/* EEPROM 保存数据格式：
* FLAG - 1Byte 保存标志位
* LEN - 2Byte 保存数据长度
* CHECK - 1Byte 保存数据校验
* DATA - nByte 保存数据内容
*
* */
/*APP*/
#define EEPROM_APP_SVAE_FLAG 0xA6
#define EEPROM_APP_DATA_Size_Max 100 //目前保存数据内容最长为100Byte
//#define EEPROM_PARA_Size 50
#define EEPROM_Offset_SaveFlag 0x00
#define EEPROM_Offset_Datalen 0x01
#define EEPROM_Offset_Check 0x03
#define EEPROM_Offset_Data 0x04
#define EEPROM_TempDifference_Default 0x09 //温差 - 默认为0x09
#define EEPROM_TempSelect_Default 0x00 //温度显示 - 默认摄氏度
#define EEPROM_TouchLevel_Default 0x01 //触摸按键等级 - 默认为0x01 中灵敏度
#define EEPROM_LangueSelect_Default 0x00 //显示语言 - 默认0x00中英文混合
#define ACTIVE_PORT 0x02 //主动端口
#define POLLING_PORT 0x01 //轮训端口
/*boot*/
#define EEPROM_SVAE_FLAG 0xAE
#define EEPROM_DATA_Size_Max 0x40 //目前保存数据内容最长为100Byte
#define EEPROM_PARA_Size 50
#define EEPROM_DEV_NAME_Size 32
typedef struct{
U8_T dev_addr; //设备地址
U8_T pipe_flag; //管制选择
U8_T temp_diff; //温差 0~18
U8_T temp_select; //温度显示单位选择 0x00:摄氏度 0x01:华氏度
U8_T backlight_en; //背光延时关闭标记 0x00:延时关 0x01:延时关闭开
U8_T key_sens_level; //按键灵敏度
U8_T langue_select; //设置显示语言
U8_T dev_port; //设备处于RCU的端口类型 1：轮训端口 2：主动端口 2024-12-16增加
}E_PARA_INFO;
typedef struct{
U8_T dev_addr; //设备地址
U8_T dev_type; //设备类型
U8_T dev_boot_ver; //设备Boot的软件版本号
U8_T dev_app_ver; //设备APP的软件版本号
U8_T dev_name_len; //设备名称的长度
U8_T dev_name[EEPROM_DEV_NAME_Size]; //设备名称
}E_MCU_DEV_INFO;
extern E_MCU_DEV_INFO g_mcu_dev;
extern E_PARA_INFO g_eeprom;
void EEPROM_Init(void);
U8_T EEPROM_CheckSum(U8_T *data,U16_T len);
U8_T EEPROM_ReadParaInfo(E_PARA_INFO *info);
U8_T EEPROM_WriteParaInfo(E_PARA_INFO *info);
U8_T EEPROM_ClearParaInfo(void);
U8_T EEPROM_Validate_ParaInfo(E_PARA_INFO *info);
void EEPROM_Default_ParaInfo(E_PARA_INFO *info);
/*boot*/
U8_T EEPROM_ReadMCUDevInfo(E_MCU_DEV_INFO *info);
U8_T EEPROM_WriteMCUDevInfo(E_MCU_DEV_INFO *info);
void EEPROM_Default_MCUDevInfo(E_MCU_DEV_INFO *info);
void EEPROM_Validate_MCUDevInfo(E_MCU_DEV_INFO *info);
#endif

105
Source/SYSTEM/inc/tempctrl_unit.h Normal file
View File

@@ -0,0 +1,105 @@
#ifndef __TEMPCTRL_UNIT_H__
#define __TEMPCTRL_UNIT_H__
#include "apt32f102_types_local.h"
/*温控相关宏定义开始*/
#define TEM_MIN_SET 0x10 //最低温度
#define TEM_MAX_SET 0x20 //最高温度
#define TEM_VALVE_OPEN 0x01 //阀开
#define TEM_VALVE_CLOSE 0x00 //阀关
#define FAN_LOW 0x00 //低风速
#define FAN_MID 0x01 //中风速
#define FAN_HIGH 0x02 //高风速
#define FAN_AUTO 0x03 //自动风
#define FAN_STOP 0x04 //停
#define MODEL_COLD 0x00 //制冷模式
#define MODEL_HOT 0x02 //制热模式
#define MODEL_WIND 0x04 //送风模式
#define MODEL_AUTO 0x06 //自动模式
#define TEMP_ON 0x01 //开机
#define TEMP_OFF 0x00 //关机
#define CARDIN 0x01 //插卡
#define CARDOUT 0x00 //拔卡
#define TEM_DEPARTTURE 0x09 //偏差温度标准
#define uint5_t(data) (data&0x1f)
#define TEMSTATECONVER(data) (*(U16_T *)&data) //实际u16的值
#define TEMTEMPCONVER(data) ((0x00 == data)?TEM_MAX_SET:data) //温控器温度转换为0，就输出32度
/*温控相关宏定义结束*/
typedef struct
{
U32_T indoor_t : 8; //0~50(°C)，室温
U32_T set_t : 8; //5~40（°C），设定温度
U32_T valve : 1; //阀门状态
U32_T fan : 3; //风速
U32_T mode : 3; //工作模式
U32_T on_off : 1; //开关机状态
U32_T reserved : 8;
}TemState_Struct;
typedef struct
{
TemState_Struct TemState_Now;
TemState_Struct TemStateLast; //温控器的上一个状态 用于输出屏幕
TemState_Struct TemState_Ctrller; //中宏网关读取到的温控状态
U8_T Temp_dirwind; //风向值,不做控制，值只记录，默认0
// U16_T IndoorTem;
// U16_T IndoorTemLast; //用于显示
//
// U16_T ReportTem; //用于上报
// U16_T ReportTemLast;
U8_T CardState; //插卡状态
U8_T CardFlag; //插卡状态改变标记
U8_T CardEn; //插卡状态功能启用标记
U8_T SceneNo; //场景编号
U8_T SceneFlag; //场景改变标记
U8_T TempChange_Flag; //状态改变标记
U8_T TempCtrller_Cnt; //发送次数
U8_T TempCtrllerChange_Flag;//状态改变下发网关标记
U32_T SceneNoTick;
U32_T Temp_SendTick; //温度定时上报间隔时间戳
U32_T TempChange_Tick;
U32_T TemQuery_1S_tick; //查询网关温控状态时间戳
}TempCtrl_Unit;
extern TempCtrl_Unit TempCtrl;
void Debug_Init(void);
void DisPlay_Task(void);
/*相关函数声明开始*/
void TemCtrl_Init(void); //初始化函数
void TemCtrl_Pro(void);
U8_T Ctrller_RecData_Processing(U8_T *RecData, U16_T Len);
void Ctrller_Query_AirFun(void);
void Ctrller_Query_AirState(void);
void Ctrller_Ctrl_AirState(void);
/*相关函数声明结束*/
#endif

152
Source/SYSTEM/inc/uart.h Normal file
View File

@@ -0,0 +1,152 @@
#ifndef _UART_H_
#define _UART_H_
#include "apt32f102.h"
#include "apt32f102_uart.h"
#define Recv_2400_TimeOut 3 //ms
#define Recv_9600_TimeOut 3 //ms
#define Recv_115200_TimeOut 3 //ms
#define USART_BUFFER_NUM 3
#define USART_BUFFER_SIZE 100
#define USART_SEND_SIZE 100
#define READ_RXLEVEL_STATE GPIO_Read_Status(GPIOB0,5) //RCU通讯485总线RX引脚
#define UART_SEND_BUFFER_NUM 10
#define UART_SEND_BUFFER_SIZE 20
#define UART_BUSBUSY 0x01 //总线繁忙
#define UART_BUSIDLE 0x00 //总线空闲
#define BUSSend_ValidTime1 60000 //数据有效期
#define BUSSend_ValidTime2 1000 //数据有效期
#define BUSSend_ValidTime3 300 //数据有效期
#define BUSSend_Cnt 1 //数据发送次数
#define BUSSend_Tick 300 //数据发送间隔
/*调试信息相关定义*/
#ifndef DBG_LOG_EN
#define DBG_LOG_EN 0 //DEBUG LOG 输出总开关
#endif
/*调试信息初始状态*/
#define DBG_OPT_Debug_STATUS 0 //临时调试信息打印开关
#define DBG_OPT_DEVICE_STATUS 0 //设备驱动层打印调试信息打印开关
#define DBG_OPT_SYS_STATUS 1 //系统调试信息打印开关
/*调试信息输出控制位*/
#define DBG_BIT_Debug_STATUS 2
#define DBG_BIT_DEVICE_STATUS 1
#define DBG_BIT_SYS_STATUS 0
#if DBG_LOG_EN
#define DBG_SendByte(data) UARTTxByte(UART2,data)
//#define DBG_Printf(data,len) UARTTransmit(UART2,data,len)
#define DBG_Printf(data,len) MCU485_SendData(data,len)
#else
#define DBG_SendByte(data) //UARTTxByte(UART1,data)
#define DBG_Printf
#endif
typedef U8_T (*Uart_prt)(U8_T *,U16_T);
typedef enum
{
UART_0,
UART_1,
UART_2,
UART_3,
UART_MAX,
}UART_IDX;
typedef enum
{
BUSSEND_SUCC = 0x00, //发送成功
BUSSEND_WAIT, //等待发送机会
DATA_END, //数据有效期结束
RETRY_END, //重发结束
LEN_ERR, //长度错误
}BUSSEND_REV;
typedef struct{
U8_T RecvBuffer[USART_BUFFER_SIZE];
U8_T Receiving;
U16_T RecvLen;
U32_T RecvTimeout;
U32_T RecvIdleTiming;
Uart_prt processing_cf; //处理函数指针
}UART_t;
typedef struct{ //总线繁忙判断
U8_T SendBuffer[USART_SEND_SIZE]; //发送缓冲
U8_T BusState_Flag; //总线繁忙标记位， 0x01:总线繁忙，0x00:总线空闲
U8_T HighBit_Flag; //串口RX高电平标记位,默认是高电平0x01.
U8_T BUSBUSY_LOCK; //锁定总线繁忙状态
U8_T SendState; //当前发送状态
U8_T ResendCnt; //当前发送次数
U8_T ASend_Flag; //主动上报发送标记
U8_T TotalCnt; //发送总次数
U8_T SetBaudFlag; //设置波特率
U8_T Jump_Flag; //跳转标志位
U16_T SendLen; //发送缓冲区数据长度
U32_T Bus_DelayTime; //总线繁忙转换到空闲状态的随机延时时间
U32_T DataWait_Time; //上报数据间隔
U32_T DataValid_Time; //上报数据有效期
U32_T BusState_Tick; //总线繁忙状态判断时间戳
U32_T ASend_Tick; //主动上报发送间隔判断时间戳
U32_T BusbusyTimeout; //上报数据有效期判断时间戳
}MULIT_t;
extern MULIT_t m_send;
extern UART_t g_uart[3];
extern U32_T Dbg_Switch;
extern U8_T DealBuffer[USART_BUFFER_SIZE]; //数据处理缓冲
extern U16_T DealLen;
extern volatile int RS485_Comm_Flag,RS485_Comm_Start,RS485_Comm_End,RS485_Comming;
extern volatile int RS485_Comm_Flag1,RS485_Comm_Start1,RS485_Comm_End1,RS485_Comming1;
void UARTx_Init(UART_IDX uart_id, Uart_prt prt_cf);
void UART1_RecvINT_Processing(char data);
void UART1_TASK(void);
void UART2_TASK(void);
void UART0_RecvINT_Processing(char data);
void UART1_RecvINT_Processing(char data);
void UART2_RecvINT_Processing(char data);
void MCU485_SendData(U8_T *buff,U16_T len);
void Controller485_SendData(U8_T *buff,U16_T len);
void Dbg_Print(int DbgOptBit, const char *cmd, ...);
void Dbg_Println(int DbgOptBit, const char *cmd, ...);
void Dbg_Print_Buff(int DbgOptBit, const char *cmd, U8_T *buff,U16_T len);
void BusIdle_Task(void);
void BusBusy_Task(void);
void BUS485Send_Task(void);
U8_T MultSend_Task(U8_T *buff,U16_T len,U8_T DatSd);
U8_T BUS485_Send(U8_T *buff,U16_T len);
void Set_GroupSend(U8_T *data,U16_T sled,U8_T SCnt,U32_T indate,U32_T tim_val);
void Clear_SendFlag(void);
U8_T Get_BUS485_Send_State(void);
void BUS485_Jump_Boot(U8_T jump);
#endif

16
Source/SYSTEM/inc/uart_protocol.h Normal file
View File

@@ -0,0 +1,16 @@
#ifndef __UART_PROTOCOL_H__
#define __UART_PROTOCOL_H__
#include "apt32f102_types_local.h"
#include "uart.h"
#define Tem_Type 0x04 //温控器类型
void Rs485AskCtrlSend(U8_T* Recdata);
void Rs485_ASend(U32_T valtim);
U8_T IrSend_Rs485_Pro(U8_T *RecData, U16_T Len);
#endif

415
Source/SYSTEM/tempctrl_unit.c Normal file
View File

@@ -0,0 +1,415 @@
#include "includes.h"
TempCtrl_Unit TempCtrl;
/******************************************************************
* 函数功能：温控初始化
*
*
*****************************************************************/
void TemCtrl_Init(void)
{
memset(&TempCtrl,0x00,sizeof(TempCtrl_Unit));
if(Sys_RSR & 0xFFFFFFFE) //除上电复位外其他复位源则恢复温控状态
{
Dbg_Println(DBG_BIT_SYS_STATUS,"MCU reset,recover state!");
if(((Sav_Temp & 0xFF) == TEMP_OFF) || ((Sav_Temp & 0xFF) == TEMP_ON)) //读取的温控开关机状态合法
{
TempCtrl.TemState_Now.on_off = (Sav_Temp & 0xFF);
}
else
{
TempCtrl.TemState_Now.on_off = TEMP_OFF;
}
if( (((Sav_Temp >> 8) & 0xFF) == MODEL_COLD) || (((Sav_Temp >> 8) & 0xFF) == MODEL_HOT)
|| (((Sav_Temp >> 8) & 0xFF) == MODEL_WIND) || (((Sav_Temp >> 8) & 0xFF) == MODEL_AUTO) ) //读取的温控模式状态合法
{
TempCtrl.TemState_Now.mode = ((Sav_Temp >> 8) & 0xFF);
}
else
{
TempCtrl.TemState_Now.mode = MODEL_COLD;
}
if( (((Sav_Temp >> 16) & 0xFF) == FAN_LOW) || (((Sav_Temp >> 16) & 0xFF) == FAN_MID) //读取的温控风速状态合法
|| (((Sav_Temp >> 16) & 0xFF) == FAN_HIGH)|| (((Sav_Temp >> 16) & 0xFF) == FAN_AUTO))
{
TempCtrl.TemState_Now.fan = ((Sav_Temp >> 16) & 0xFF);
}
else
{
TempCtrl.TemState_Now.fan = FAN_MID;
}
//读取的温控设置温度合法 2024-04-18增加0==32的判断
if(((((Sav_Temp >> 24) & 0xFF) >= 16) && (((Sav_Temp >> 24) & 0xFF) <= 32)) )
{
TempCtrl.TemState_Now.set_t = ((Sav_Temp >> 24) & 0xFF);
}
else
{
TempCtrl.TemState_Now.set_t = 24;
}
}
else //正常上电温控状态
{
TempCtrl.TemState_Now.on_off = TEMP_OFF; //关机
TempCtrl.TemState_Now.mode = MODEL_COLD; //制冷
TempCtrl.TemState_Now.fan = FAN_MID; //中风速
TempCtrl.TemState_Now.set_t = 24; //24
}
TempCtrl.TemState_Now.indoor_t = 24;
TempCtrl.TemStateLast.indoor_t = TempCtrl.TemState_Now.indoor_t;
TempCtrl.TemState_Ctrller.indoor_t = TempCtrl.TemState_Now.indoor_t;
SYSCON->UREG0 = 0x00000000;
SYSCON->UREG0 |= (TempCtrl.TemState_Now.mode << 8);
SYSCON->UREG0 |= (TempCtrl.TemState_Now.fan << 16);
SYSCON->UREG0 |= (TempCtrl.TemState_Now.set_t << 24);
SYSCON->UREG0 |= TempCtrl.TemState_Now.on_off; //2024-03-15
}
/******************************************************************
* 函数功能：温控轮询任务,获得温控器状态、阀门状态
*
*
*****************************************************************/
void TemCtrl_Pro(void)
{
static uint32_t TemCtrl_tick = 0x00;
//2、网关读取到的开关机状态
if(TempCtrl.TemState_Now.on_off != TempCtrl.TemState_Ctrller.on_off)
{
TempCtrl.TemState_Ctrller.on_off = TempCtrl.TemState_Now.on_off;
TempCtrl.TempCtrllerChange_Flag = 0x01;
}
if(TempCtrl.TemState_Now.set_t != TempCtrl.TemState_Ctrller.set_t)
{
TempCtrl.TemState_Ctrller.set_t = TempCtrl.TemState_Now.set_t;
TempCtrl.TempCtrllerChange_Flag = 0x01;
}
if(TempCtrl.TemState_Now.mode != TempCtrl.TemState_Ctrller.mode)
{
TempCtrl.TemState_Ctrller.mode = TempCtrl.TemState_Now.mode;
TempCtrl.TempCtrllerChange_Flag = 0x01;
}
if(TempCtrl.TemState_Now.fan != TempCtrl.TemState_Ctrller.fan)
{
TempCtrl.TemState_Ctrller.fan = TempCtrl.TemState_Now.fan;
TempCtrl.TempCtrllerChange_Flag = 0x01;
}
//3、发送控制网关空调状态命令
if( (TempCtrl.TempCtrllerChange_Flag == 0x01)&&(SysTick_1ms - TemCtrl_tick >= 300) )
{
TempCtrl.TemQuery_1S_tick = SysTick_1ms;
TemCtrl_tick = SysTick_1ms;
if(TempCtrl.TempCtrller_Cnt <= 0x03)
{
TempCtrl.TempCtrller_Cnt++;
Ctrller_Ctrl_AirState();
}else{
TempCtrl.TempCtrllerChange_Flag = 0x00;
TempCtrl.TempCtrller_Cnt = 0x00;
}
}
// //4、发送读取网关空调状态命令,获取温控器状态
// if(SysTick_1ms - TempCtrl.TemQuery_1S_tick >= 1000)
// {
// TempCtrl.TemQuery_1S_tick = SysTick_1ms;
//
// Ctrller_Query_AirState();
// }
}
/************************************************************************************
* 函数名称 : Ctrller_Query_AirFun
* 函数功能 ： 查询空调性能
* 函数输入 :
* 函数输出 :
**********************************************************************************/
void Ctrller_Query_AirFun(void)
{
U8_T SdBuff[8];
U16_T SdLen = 0x06;
SdBuff[0] = 0xDD;
SdBuff[1] = 0x06;
SdBuff[2] = 0xFF;
SdBuff[3] = g_Dip.DIP_addr;
SdBuff[4] = 0x01; //命令字
SdBuff[5] = EEPROM_CheckSum(SdBuff,0x05);
Controller485_SendData(SdBuff,SdLen);
}
/************************************************************************************
* 函数名称 : Ctrller_Query_AirState
* 函数功能 ： 查询空调状态
* 函数输入 :
* 函数输出 :
**********************************************************************************/
void Ctrller_Query_AirState(void)
{
U8_T SdBuff[8];
U16_T SdLen = 0x06;
SdBuff[0] = 0xDD;
SdBuff[1] = 0x06;
SdBuff[2] = 0xFF;
SdBuff[3] = g_Dip.DIP_addr;
SdBuff[4] = 0x02; //命令字
SdBuff[5] = EEPROM_CheckSum(SdBuff,0x05);
Controller485_SendData(SdBuff,SdLen);
}
/************************************************************************************
* 函数名称 : Ctrller_Ctrl_AirState
* 函数功能 ： 控制空调状态
* 函数输入 :
* 函数输出 :
**********************************************************************************/
void Ctrller_Ctrl_AirState(void)
{
U8_T SdBuff[12];
U16_T SdLen = 0x0B;
SdBuff[0] = 0xDD;
SdBuff[1] = 0x0B;
SdBuff[2] = 0xFF;
SdBuff[3] = g_Dip.DIP_addr;
SdBuff[4] = 0x03; //命令字
SdBuff[5] = TempCtrl.TemState_Now.on_off; //开关机状态
SdBuff[6] = TempCtrl.TemState_Now.set_t; //设定温度
if(TempCtrl.TemState_Now.mode == MODEL_COLD){ //空调工作模式, 0x01:制热, 0x02:制冷, 0x04:送风
SdBuff[7] = 0x02;
}else if(TempCtrl.TemState_Now.mode == MODEL_HOT){
SdBuff[7] = 0x01;
}else if(TempCtrl.TemState_Now.mode == MODEL_WIND){
SdBuff[7] = 0x04;
}else{
SdBuff[7] = 0x02;
}
if(TempCtrl.TemState_Now.fan == FAN_AUTO){ //空调风速, 0x00:自动, 0x01:低风速, 0x02:中风速, 0x03:高风速, 0x04:停止
SdBuff[8] = 0x00;
}else if(TempCtrl.TemState_Now.fan == FAN_LOW){
SdBuff[8] = 0x01;
}else if(TempCtrl.TemState_Now.fan == FAN_MID){
SdBuff[8] = 0x02;
}else if(TempCtrl.TemState_Now.fan == FAN_HIGH){
SdBuff[8] = 0x03;
}else if(TempCtrl.TemState_Now.fan == FAN_STOP){
SdBuff[8] = 0x04;
}else{
SdBuff[8] = 0x02;
}
SdBuff[9] = TempCtrl.Temp_dirwind; //空调的风向值, 0x00:无风向, 0x01:代表风向板位于位置1, ..., 0x07:代表风向板位于位置7, 0xFF:自动摆动
SdBuff[10] = EEPROM_CheckSum(SdBuff,0x0A);
Controller485_SendData(SdBuff,SdLen);
}
/************************************************************************************
* 函数名称 : Ctrller_AirFun_Processing
* 函数功能 ： 查询空调性能命令的回复数据处理
* 函数输入 :
* RecData : 接收数据
* Len : 接收数据长度
* 函数输出 :
**********************************************************************************/
U8_T Ctrller_AirFun_Processing(U8_T *RecData, U16_T Len)
{
if(Len < 12) return 0x01;
return 0x00;
}
/************************************************************************************
* 函数名称 : Ctrller_AirState_Processing
* 函数功能 ： 查询空调状态的回复数据处理
* 函数输入 :
* RecData : 接收数据
* Len : 接收数据长度
* 函数输出 :
**********************************************************************************/
U8_T Ctrller_AirState_Processing(U8_T *RecData, U16_T Len)
{
if(Len < 13) return 0x01;
//开关机状态, 0x00:关机, 0x01:开机
if(RecData[5] <= 0x01){
TempCtrl.TemState_Now.on_off = RecData[5];
}
//空调的设定温度, 16~30
if( (RecData[6] >= TEM_MIN_SET)&&(RecData[6] <= TEM_MAX_SET) ){
TempCtrl.TemState_Now.set_t = RecData[6];
}
//空调的工作模式, 0x01:制热, 0x02:制冷, 0x04:送风, 0x08:除湿
if(RecData[7] == 0x01){
TempCtrl.TemState_Now.mode = MODEL_HOT;
}else if(RecData[7] == 0x02){
TempCtrl.TemState_Now.mode = MODEL_COLD;
}else if(RecData[7] == 0x04){
TempCtrl.TemState_Now.mode = MODEL_WIND;
}else{
TempCtrl.TemState_Now.mode = MODEL_COLD;
}
//空调的风速, 0x00:自动, 0x01:低风速, 0x02:中风速, 0x03:高风速
if(RecData[8] == 0x00){
TempCtrl.TemState_Now.fan = FAN_AUTO;
}else if(RecData[8] == 0x01){
TempCtrl.TemState_Now.fan = FAN_LOW;
}else if(RecData[8] == 0x02){
TempCtrl.TemState_Now.fan = FAN_MID;
}else if(RecData[8] == 0x03){
TempCtrl.TemState_Now.fan = FAN_HIGH;
}else{
TempCtrl.TemState_Now.fan = FAN_LOW;
}
//空调的风向值, 0x00:无风向, 0x01:代表风向板位于位置1, ..., 0x07:代表风向板位于位置7, 0xFF:自动摆动
TempCtrl.Temp_dirwind = RecData[9];
//室内温度, 0~40
if(RecData[10] <= 40){
TempCtrl.TemState_Now.indoor_t = RecData[10];
}
//空调的故障码,
TempCtrl.TemState_Ctrller.on_off = TempCtrl.TemState_Now.on_off;
TempCtrl.TemState_Ctrller.set_t = TempCtrl.TemState_Now.set_t;
TempCtrl.TemState_Ctrller.mode = TempCtrl.TemState_Now.mode;
TempCtrl.TemState_Ctrller.fan = TempCtrl.TemState_Now.fan;
TempCtrl.TemState_Ctrller.indoor_t = TempCtrl.TemState_Now.indoor_t;
return 0x00;
}
/************************************************************************************
* 函数名称 : Ctrller_CtrlAirState_Processing
* 函数功能 ： 控制空调状态的回复数据处理
* 函数输入 :
* RecData : 接收数据
* Len : 接收数据长度
* 函数输出 :
**********************************************************************************/
U8_T Ctrller_CtrlAirState_Processing(U8_T *RecData, U16_T Len)
{
if(Len < 7) return 0x01;
if(RecData[5] == 0x00) //控制设定失败
{
}
else if(RecData[5] == 0x01) //控制设定成功
{
TempCtrl.TempCtrllerChange_Flag = 0x00;
TempCtrl.TempCtrller_Cnt = 0x00;
}
return 0x00;
}
/************************************************************************************
* 函数名称 : Ctrller_RecData_Processing
* 函数功能 ： 接收网关数据
* 函数输入 :
* RecData : 接收数据缓冲区
* Len : 接收数据长度
* 函数输出 : 处理状态
**********************************************************************************/
U8_T Ctrller_RecData_Processing(U8_T *RecData, U16_T Len)
{
if( (Len < 6)||(RecData[1] != Len) )
{
Dbg_Println(DBG_BIT_SYS_STATUS,"Len Err:%d",Len);
return 0x01;
}
if(RecData[0] != 0xCC)
{
Dbg_Println(DBG_BIT_SYS_STATUS,"Head Err");
return 0x02;
}
if( (RecData[2] != 0xFF)||(RecData[3] != g_Dip.DIP_addr) )
{
Dbg_Println(DBG_BIT_SYS_STATUS,"Addr Err:%d, %d",g_Dip.DIP_addr,RecData[3]);
return 0x03;
}
if(RecData[Len-1] != EEPROM_CheckSum(RecData,(Len-1)))
{
Dbg_Println(DBG_BIT_SYS_STATUS,"SumCRC Err:%d, %d",RecData[5],EEPROM_CheckSum(RecData,(Len-1)));
return 0x04;
}
switch(RecData[4])
{
case 0x01: //查询网关连接的空调性能的回复
Ctrller_AirFun_Processing(RecData,Len);
break;
case 0x02: //查询网关连接的空调状态的回复
//Ctrller_AirState_Processing(RecData,Len);
break;
case 0x03: //控制网关连接的空调状态的回复
Ctrller_CtrlAirState_Processing(RecData,Len);
break;
case 0x04: //查询网关连接的空调原厂故障代码值的回复
break;
default:
break;
}
return 0x00;
}

627
Source/SYSTEM/uart.c Normal file
View File

@@ -0,0 +1,627 @@
#include "includes.h"
#include <string.h>
#include <stdarg.h>
/**
* BLV_C8_PB 串口使用情况
* UART1 用与RCU进行双向通讯 115200 -> 对应设置 416
* UART0 用于PB数据发送，没有接收 9600 -> 对应设置 5000
* */
UART_t g_uart[3];
U8_T DealBuffer[USART_BUFFER_SIZE] = {0}; //数据处理缓冲
U16_T DealLen = 0x00;
MULIT_t m_send;
void UARTx_Init(UART_IDX uart_id, Uart_prt prt_cf) {
switch(uart_id){
case UART_0:
UART0_DeInit(); //clear all UART Register
UART_IO_Init(IO_UART0,0); //use PA0.1->RXD0, PA0.0->TXD0
// UARTInit(UART0,5000,UART_PAR_NONE); //baudrate=sysclock 48M/1000=4800
UARTInitRxTxIntEn(UART0,416,UART_PAR_NONE); //baudrate=sysclock 48M/1000=4800,tx rx int enabled
// UART0_Int_Enable();
memset(&g_uart[UART_0],0,sizeof(UART_t));
g_uart[UART_0].RecvTimeout = Recv_115200_TimeOut;
g_uart[UART_0].processing_cf = prt_cf;
break;
case UART_1:
UART1_DeInit(); //clear all UART Register
UART_IO_Init(IO_UART1,2); //use PA0.13->RXD1, PB0.0->TXD1
// UARTInit(UART1,416,UART_PAR_NONE); //baudrate=sysclock 48M/416=115200
UARTInitRxTxIntEn(UART1,5000,UART_PAR_NONE); //baudrate=sysclock 48M/416=115200 tx rx int enabled
UART1_Int_Enable();
memset(&g_uart[UART_1],0,sizeof(UART_t));
g_uart[UART_1].RecvTimeout = Recv_9600_TimeOut;
g_uart[UART_1].processing_cf = prt_cf;
GPIO_Init(GPIOA0,13,Output);
GPIO_DriveStrength_EN(GPIOA0,13);
GPIO_Write_Low(GPIOA0,13);
break;
case UART_2:
memset(&g_uart[UART_2],0,sizeof(UART_t));
memset(&m_send,0,sizeof(MULIT_t));
m_send.HighBit_Flag = 0x01;
g_uart[UART_2].RecvTimeout = Recv_9600_TimeOut;
g_uart[UART_2].processing_cf = prt_cf;
//2025-03-29，串口2的RX管脚外部中断，用于通讯总线繁忙判断。
GPIO_PullHigh_Init(GPIOB0,5); //RX,PB0.5
GPIO_IntGroup_Set(PB0,5,Selete_EXI_PIN5); //EXI0 set PB0.2
GPIOB0_EXI_Init(EXI5); //PB0.2 as input
EXTI_trigger_CMD(ENABLE,EXI_PIN5,_EXIFT); //ENABLE falling edge，下降沿触发
EXTI_trigger_CMD(ENABLE,EXI_PIN5,_EXIRT); //上升沿触发
EXTI_interrupt_CMD(ENABLE,EXI_PIN5); //enable EXI
GPIO_EXTI_interrupt(GPIOB0,0b0000000000100000); //enable GPIOB02 as EXI
EXI3_Int_Enable();
UART2_DeInit(); //clear all UART Register
UART_IO_Init(IO_UART2,2); //use PB0.4->RXD1, PB0.5->TXD1
//UARTInit(UART2,416,UART_PAR_NONE); //baudrate=sysclock 48M/416=115200
UARTInitRxTxIntEn(UART2,5000,UART_PAR_NONE); //baudrate=sysclock 48M/416=115200 tx rx int enabled
UART2_Int_Enable();
GPIO_Init(GPIOB0,3,Output);
GPIO_DriveStrength_EN(GPIOB0,3);
GPIO_Write_Low(GPIOB0,3);
break;
}
}
/*******************************************************************************
* Function Name : UART0_RecvINT_Processing
* Description : 串口0 接收中断处理函数 - 接收中断调用
*******************************************************************************/
void UART0_RecvINT_Processing(char data){
if((g_uart[UART_0].RecvLen + 1) >= USART_BUFFER_SIZE) g_uart[UART_0].RecvLen = 0;
g_uart[UART_0].RecvBuffer[g_uart[UART_0].RecvLen++] = (U8_T)data;
g_uart[UART_0].RecvIdleTiming = SysTick_1ms;
g_uart[UART_0].Receiving = 0x01;
}
void UART0_TASK(void){
if(g_uart[UART_0].Receiving == 0x01){
if(SysTick_1ms - g_uart[UART_0].RecvIdleTiming > g_uart[UART_0].RecvTimeout){
g_uart[UART_0].RecvIdleTiming = SysTick_1ms;
Dbg_Println(DBG_BIT_SYS_STATUS, "UART0 recv Len %d", g_uart[UART_0].RecvLen);
Dbg_Print_Buff(DBG_BIT_SYS_STATUS,"UART0 buff",g_uart[UART_0].RecvBuffer,g_uart[UART_0].RecvLen);
if(g_uart[UART_0].processing_cf != NULL){
g_uart[UART_0].processing_cf(g_uart[UART_0].RecvBuffer,g_uart[UART_0].RecvLen);
}
g_uart[UART_0].RecvLen = 0;
g_uart[UART_0].Receiving = 0;
}
}
}
/*******************************************************************************
* Function Name : UART1_RecvINT_Processing
* Description : 串口1 接收中断处理函数 - 接收中断调用
*******************************************************************************/
void UART1_RecvINT_Processing(char data){
if((g_uart[UART_1].RecvLen + 1) >= USART_BUFFER_SIZE) g_uart[UART_1].RecvLen = 0;
g_uart[UART_1].RecvBuffer[g_uart[UART_1].RecvLen++] = (U8_T)data;
g_uart[UART_1].RecvIdleTiming = SysTick_1ms;
g_uart[UART_1].Receiving = 0x01;
}
void UART1_TASK(void){
U8_T rev = 0xFF;
if(g_uart[UART_1].Receiving == 0x01){
if(SysTick_1ms - g_uart[UART_1].RecvIdleTiming > g_uart[UART_1].RecvTimeout){
SYSCON_Int_Disable(); //2025-03-19,复制接收缓冲到数据处理缓冲内
g_uart[UART_1].RecvIdleTiming = SysTick_1ms;
memcpy(DealBuffer,g_uart[UART_1].RecvBuffer,g_uart[UART_1].RecvLen);
DealLen = g_uart[UART_1].RecvLen;
g_uart[UART_1].RecvLen = 0;
g_uart[UART_1].Receiving = 0;
SYSCON_Int_Enable();
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS, "UART1 recv Len %d", DealLen);
Dbg_Print_Buff(DBG_BIT_SYS_STATUS,"UART1 buff",DealBuffer,DealLen);
#endif
if(g_uart[UART_1].processing_cf != NULL){
rev = g_uart[UART_1].processing_cf(DealBuffer,DealLen);
}
memset(DealBuffer,0,USART_BUFFER_SIZE);
}
}
}
/*******************************************************************************
* Function Name : UART2_RecvINT_Processing
* Description : 串口2 接收中断处理函数 - 接收中断调用
*******************************************************************************/
void UART2_RecvINT_Processing(char data){
if((g_uart[UART_2].RecvLen + 1) >= USART_BUFFER_SIZE) g_uart[UART_2].RecvLen = 0;
g_uart[UART_2].RecvBuffer[g_uart[UART_2].RecvLen++] = (U8_T)data;
g_uart[UART_2].RecvIdleTiming = SysTick_1ms;
g_uart[UART_2].Receiving = 0x01;
}
void UART2_TASK(void){
U8_T rev = 0xFF;
if(g_uart[UART_2].Receiving == 0x01){
if(SysTick_1ms - g_uart[UART_2].RecvIdleTiming > g_uart[UART_2].RecvTimeout){
SYSCON_Int_Disable(); //2025-03-19,复制接收缓冲到数据处理缓冲内
g_uart[UART_2].RecvIdleTiming = SysTick_1ms;
memcpy(DealBuffer,g_uart[UART_2].RecvBuffer,g_uart[UART_2].RecvLen);
DealLen = g_uart[UART_2].RecvLen;
g_uart[UART_2].RecvLen = 0;
g_uart[UART_2].Receiving = 0;
SYSCON_Int_Enable();
#if DBG_LOG_EN
Dbg_Println(DBG_BIT_SYS_STATUS, "UART2 recv Len %d", DealLen);
Dbg_Print_Buff(DBG_BIT_SYS_STATUS,"UART2 buff",DealBuffer,DealLen);
#endif
if(g_uart[UART_2].processing_cf != NULL){
rev = g_uart[UART_2].processing_cf(DealBuffer,DealLen);
}
// /*Boot处理函数 */
// if(rev != 0x00)
// {
// Boot_Comm_UpgradeProcess(DealBuffer,DealLen);
// }
memset(DealBuffer,0,USART_BUFFER_SIZE);
}
}
}
/*因为开启了UART_TX_DONE_S 中断，发送完成需要清楚该中断标志位，因此每次调用串口输出后，需调用该函数，否则会在中断出不来
* 已取消
* */
void UART_Waiting_For_Send(CSP_UART_T *uart){
unsigned int Dataval = 0,delay_cnt = 0;
do{
Dataval = CSP_UART_GET_ISR(uart);
Dataval = Dataval & UART_TX_DONE_S;
delay_cnt ++;
if(delay_cnt >= 50000){
break;
}
}while(Dataval == 0x00); //发送完成
uart->ISR=UART_TX_DONE_S;
}
volatile int RS485_Comm_Flag = 0,RS485_Comm_Start = 0,RS485_Comm_End = 0,RS485_Comming = 0;
volatile int RS485_Comm_Flag1 = 0,RS485_Comm_Start1 = 0,RS485_Comm_End1 = 0,RS485_Comming1 = 0;
void MCU485_SendData(U8_T *buff,U16_T len){
unsigned int Dataval = 0,delay_cnt = 0;
//等待通讯发送完成
while(RS485_Comming == 0x01){
delay_nus(100);
delay_cnt ++;
if(delay_cnt >= 100){
break;
}
GPIO_Reverse(GPIOB0,3);
}
delay_nus(500);
CK_CPU_DisAllNormalIrq();
GPIO_Write_High(GPIOB0,3);
RS485_Comm_Flag = 0x01;
RS485_Comm_Start = 0x00;
RS485_Comm_End = 0x00;
CK_CPU_EnAllNormalIrq();
UARTTransmit(UART2,buff,len);
do{
delay_nus(100);
delay_cnt ++;
if(delay_cnt >= 100){
break;
}
}while((RS485_Comm_Start < len) || (RS485_Comm_End < len)); //发送完成
CK_CPU_DisAllNormalIrq();
GPIO_Write_Low(GPIOB0,3);
RS485_Comm_Flag = 0x00;
CK_CPU_EnAllNormalIrq();
}
//发送给设备端的485发送函数
void Controller485_SendData(U8_T *buff,U16_T len)
{
unsigned int Dataval = 0,delay_cnt = 0;
//等待通讯发送完成
while(RS485_Comming1 == 0x01){
delay_nus(100);
delay_cnt ++;
if(delay_cnt >= 100){
break;
}
GPIO_Reverse(GPIOA0,13);
}
delay_nus(500);
CK_CPU_DisAllNormalIrq();
GPIO_Write_High(GPIOA0,13);
RS485_Comm_Flag1 = 0x01;
RS485_Comm_Start1 = 0x00;
RS485_Comm_End1 = 0x00;
CK_CPU_EnAllNormalIrq();
UARTTransmit(UART1,buff,len);
do{
delay_nus(100);
delay_cnt ++;
if(delay_cnt >= 100){
break;
}
}while((RS485_Comm_Start1 < len) || (RS485_Comm_End1 < len)); //发送完成
CK_CPU_DisAllNormalIrq();
GPIO_Write_Low(GPIOA0,13);
RS485_Comm_Flag1 = 0x00;
CK_CPU_EnAllNormalIrq();
}
/**********************************************************
* @brief 带总线状态判断的485发送
* buff:发送数据
* len：数据长度
* @retval
* */
U8_T BUS485_Send(U8_T *buff,U16_T len)
{
unsigned int Dataval = 0,delay_cnt = 0;
//等待通讯发送完成
while(RS485_Comming == 0x01){
delay_nus(100);
delay_cnt ++;
if(delay_cnt >= 100){
break;
}
GPIO_Reverse(GPIOB0,3);
}
if(m_send.BusState_Flag == UART_BUSIDLE){ //总线空闲
CK_CPU_DisAllNormalIrq();
GPIO_Write_High(GPIOB0,3);
RS485_Comm_Flag = 0x01;
RS485_Comm_Start = 0x00;
RS485_Comm_End = 0x00;
m_send.BusState_Flag = UART_BUSBUSY;//发送前总线置位繁忙
m_send.BUSBUSY_LOCK = 0x01; //锁定总线状态
CK_CPU_EnAllNormalIrq();
UARTTransmit(UART2,buff,len);
do{
delay_nus(100);
delay_cnt ++;
if(delay_cnt >= 100){
break;
}
}while((RS485_Comm_Start < len) || (RS485_Comm_End < len)); //发送完成
CK_CPU_DisAllNormalIrq();
GPIO_Write_Low(GPIOB0,3);
RS485_Comm_Flag = 0x00;
m_send.BusState_Tick = SysTick_1ms;
m_send.BUSBUSY_LOCK = 0x00; //解锁总线状态
CK_CPU_EnAllNormalIrq();
return UART_BUSIDLE; //发送成功
}
else //总线繁忙
{
return UART_BUSBUSY; //发送失败
}
return 0x02; //传入状态无效
}
/**********************************************************
* @brief 重发、数据有效期、超时发送判断，2025-03-25
* buff:发送数据
* len：数据长度
* DatSd：发送标记,0x00:无发送，0x01：有数据发送
*
* @retval 0x00:发送成功 0x01:等待发送 0x02:数据无效
* */
U8_T MultSend_Task(U8_T *buff,U16_T len,U8_T DatSd)
{
if( (len == 0)||(len > USART_SEND_SIZE) ) return LEN_ERR;
if(DatSd == 0x01)
{
if( m_send.ResendCnt < m_send.TotalCnt) //判断数据是否还在有效期，是否还有发送次数
{
if(SysTick_1ms - m_send.BusbusyTimeout < m_send.DataValid_Time)
{
if( (m_send.ResendCnt == 0x00) || (SysTick_1ms - m_send.ASend_Tick >= m_send.DataWait_Time) ){//数据发送间隔
if(BUS485_Send(buff,len) == UART_BUSIDLE){ //发送数据
m_send.ASend_Tick = SysTick_1ms;
m_send.ResendCnt++;
Dbg_Println(DBG_BIT_SYS_STATUS,"SendCnt:%d success",m_send.ResendCnt);
return BUSSEND_SUCC;//数据发送成功
}
}
}else{
Dbg_Println(DBG_BIT_SYS_STATUS,"data end");
return DATA_END;//数据有效期结束
}
}else{
Dbg_Println(DBG_BIT_SYS_STATUS,"retry end,%d",m_send.ResendCnt );
return RETRY_END;//没有重发次数
}
}
return BUSSEND_WAIT;//等待
}
/**********************************************************
* @brief 设置发送标志、组包、选择数据有效期档位，2025-03-25
* data: 发送数据
* sled： 数据长度
* SCnt: 设置数据发送次数
* indate： 设置数据有效期
* tim_val: 发送时间间隔
* @retval None
* */
void Set_GroupSend(U8_T *data,U16_T sled,U8_T SCnt,U32_T indate,U32_T tim_val)
{
if((sled == 0x00)|| (sled > USART_SEND_SIZE)) return;
memset(m_send.SendBuffer,0, USART_SEND_SIZE);
memcpy(m_send.SendBuffer,data,sled);
m_send.SendLen = sled;
m_send.DataValid_Time = indate;//数据有效期
m_send.TotalCnt = SCnt; //数据发送次数
m_send.DataWait_Time = tim_val;//发送数据间隔
m_send.ASend_Flag = 0x01;
m_send.SendState = BUSSEND_WAIT;
m_send.ResendCnt = 0x00;
m_send.BusbusyTimeout = SysTick_1ms;
}
//清除发送标志
void Clear_SendFlag(void)
{
m_send.ASend_Flag = 0x00;
m_send.SendState = BUSSEND_SUCC;
}
void BUS485_Jump_Boot(U8_T jump)
{
m_send.Jump_Flag = jump;
}
//485发送任务
void BUS485Send_Task(void) //2025-03-29
{
//空闲等待
if(m_send.ASend_Flag == 0x01)
{
m_send.SendState = MultSend_Task(m_send.SendBuffer,m_send.SendLen,m_send.ASend_Flag);
if( (m_send.SendState == DATA_END)||(m_send.SendState == RETRY_END) )//判断发送数据是否有效
{
Dbg_Println(DBG_BIT_SYS_STATUS,"send end");
m_send.ASend_Flag = 0x00; //清除发生标志位
/*设置波特率*/
// if( m_send.SetBaudFlag == 0x01 ){
//
// UARTx_ChangeBaud(UART_2,m_send.SetBaud);
// m_send.SetBaudFlag = 0x00;
// m_send.SetBaud = 0x00;
// }
// if(m_send.Jump_Flag == 0x01){
// Dbg_Println(DBG_BIT_Debug_STATUS,"Jump Boot");
//
// SYSCON->UREG3 = g_boot.bootTimeout; //向Boot 设定Boot超时时间
// SYSCON_Software_Reset();
// }
}
}
}
//获取当前BUS485 发生状态，获取完状态后清除当前状态
U8_T Get_BUS485_Send_State(void)
{
U8_T rev_state = 0x0F;
if(m_send.ASend_Flag == 0x01){
rev_state |= 0x80;
}
rev_state |= (m_send.SendState & 0x0F);
return rev_state;
}
/**********************************************************
* @brief 2025-03-25，检测总线空闲，在定时器中断里调用
* @retval None
* */
void BusIdle_Task(void)
{
if((m_send.BusState_Flag != UART_BUSIDLE)&&(m_send.BUSBUSY_LOCK != 0x01))
{
CK_CPU_DisAllNormalIrq();
if( (m_send.HighBit_Flag == 0x01)&&(SysTick_1ms - m_send.BusState_Tick >= (6 + m_send.Bus_DelayTime)) )
{
m_send.BusState_Flag = UART_BUSIDLE;
}
CK_CPU_EnAllNormalIrq();
}
}
/*******************************************************************
* @brief 检测总线繁忙，在串口接收RX引脚的外部中断服务函数里调用
* @retval None
* */
void BusBusy_Task(void)
{
CK_CPU_DisAllNormalIrq();
m_send.BusState_Flag = UART_BUSBUSY;
m_send.BusState_Tick = SysTick_1ms;
m_send.Bus_DelayTime = (SysTick_1ms - m_send.ASend_Tick)%10;//随机延时
if(READ_RXLEVEL_STATE == 0x01){
m_send.HighBit_Flag = 0x01; //高电平标志置位
}else if(READ_RXLEVEL_STATE == 0x00){
m_send.HighBit_Flag = 0x00; //低电平
}
CK_CPU_EnAllNormalIrq();
}
/*调试信息输出接口*/
U32_T Dbg_Switch = (DBG_OPT_Debug_STATUS << DBG_BIT_Debug_STATUS)
+ (DBG_OPT_DEVICE_STATUS << DBG_BIT_DEVICE_STATUS)
+ (DBG_OPT_SYS_STATUS << DBG_BIT_SYS_STATUS);
#if DBG_LOG_EN
char Dbg_Buffer[128] = {0};
U32_T SysTick_Now = 0, SysTick_Last = 0, SysTick_Diff = 0;
#endif
void Dbg_Print(int DbgOptBit, const char *cmd, ...){
#if DBG_LOG_EN
U16_T str_offset = 0;
if (Dbg_Switch & (1 << DbgOptBit)) {
SysTick_Now = SysTick_1ms;
SysTick_Diff = SysTick_Now - SysTick_Last; //上一次打印时间差
SysTick_Last = SysTick_Now;
str_offset = snprintf(Dbg_Buffer, sizeof(Dbg_Buffer),"%8d [%6d]: ", SysTick_Now, SysTick_Diff);
DBG_Printf(Dbg_Buffer,str_offset);
va_list args; //定义一个va_list类型的变量，用来储存单个参数
va_start(args, cmd); //使args指向可变参数的第一个参数
str_offset = vsnprintf(Dbg_Buffer, sizeof(Dbg_Buffer) ,cmd, args); //必须用vprintf等带V的
va_end(args); //结束可变参数的获取
DBG_Printf(Dbg_Buffer,str_offset);
}
#endif
}
void Dbg_Println(int DbgOptBit, const char *cmd, ...){
#if DBG_LOG_EN
U16_T str_offset = 0;
if (Dbg_Switch & (1 << DbgOptBit)) {
SysTick_Now = SysTick_1ms;
SysTick_Diff = SysTick_Now - SysTick_Last; //上一次打印时间差
SysTick_Last = SysTick_Now;
str_offset = snprintf(Dbg_Buffer, sizeof(Dbg_Buffer) , "%8ld [%6ld]: ", SysTick_Now, SysTick_Diff);
DBG_Printf(Dbg_Buffer,str_offset);
va_list args; //定义一个va_list类型的变量，用来储存单个参数
va_start(args, cmd); //使args指向可变参数的第一个参数
str_offset = vsnprintf(Dbg_Buffer, sizeof(Dbg_Buffer) ,cmd, args); //必须用vprintf等带V的
va_end(args); //结束可变参数的获取
DBG_Printf(Dbg_Buffer,str_offset);
DBG_Printf("\r\n",2);
}
#endif
}
void Dbg_Print_Buff(int DbgOptBit, const char *cmd, U8_T *buff,U16_T len){
#if DBG_LOG_EN
U16_T str_offset = 0;
if (Dbg_Switch & (1 << DbgOptBit)) {
SysTick_Now = SysTick_1ms;
SysTick_Diff = SysTick_Now - SysTick_Last; //上一次打印时间差
SysTick_Last = SysTick_Now;
str_offset = snprintf(Dbg_Buffer, sizeof(Dbg_Buffer) , "%8ld [%6ld]: ", SysTick_Now, SysTick_Diff);
DBG_Printf(Dbg_Buffer,str_offset);
for (uint32_t i = 0; i < len; i++) {
str_offset = snprintf(Dbg_Buffer, sizeof(Dbg_Buffer) , "%02X ", buff[i]);
DBG_Printf(Dbg_Buffer,str_offset);
}
DBG_Printf("\r\n",2);
}
#endif
}

207
Source/SYSTEM/uart_protocol.c Normal file
View File

@@ -0,0 +1,207 @@
#include "includes.h"
/*两字节CRC校验
*len包括校验的长度
*/
void NetCRC16_Check(U8_T *aStr ,U16_T len)
{
U16_T alen = len-2; //CRC16???????
U16_T xda , xdapoly ; //校验后的结果，多项式
U16_T i,j, xdabit ; //缓存变量
if(len < 3) //长度小于3
{
return ; //直接返回
}
xda = 0xFFFF ;
xdapoly = 0xA001 ; // (X**16 + X**15 + X**2 + 1)
for(i=0;i<alen;i++)
{
xda ^= aStr[i] ;
for(j=0;j<8;j++)
{
xdabit = (U8_T)(xda & 0x01) ;
xda >>= 1 ;
if( xdabit ) xda ^= xdapoly ;
}
}
aStr[alen] = (U8_T)(xda & 0xFF) ;
aStr[alen+1] = (U8_T)(xda>>8) ;
}
/** @name CRC16校验得到
* @para
* aStr 数组首地址
* len 数组长度，不包括校验
*/
U16_T GetCRC16( U8_T *aStr , U16_T len)
{
U16_T xda , xdapoly ;
U16_T i, j, xdabit ;
xda = 0xFFFF ;
xdapoly = 0xA001 ; // (X**16 + X**15 + X**2 + 1)
for (i = 0; i < len; i++)
{
xda ^= aStr[i] ;
for (j = 0; j < 8; j++)
{
xdabit = (unsigned char)(xda & 0x01) ;
xda >>= 1 ;
if ( xdabit ) xda ^= xdapoly ;
}
}
return xda;
}
/*和校验*/
U8_T SOR_CRC(U8_T *Data, U8_T DataLen)
{
U8_T i;
U8_T sor_data = 0;
for(i = 0; i < DataLen; i++)//i可能为0 ，也可以是1
{
sor_data = sor_data+Data[i];
}
return sor_data;
}
/*控制回复报文*/
void Rs485AskCtrlSend(U8_T* Recdata)
{
U8_T SendData[10];
SendData[0] = 0x55;
SendData[1] = 0x55;
SendData[2] = 0xee; //头
SendData[3] = 0x07; //长度
SendData[4] = Tem_Type; //类型
SendData[6] = 0x01; //类型 - 红外转发
SendData[5] = g_Dip.DIP_addr;
SendData[7] = 0x01; //内容 - 接收成功
NetCRC16_Check(&SendData[0+3], SendData[0+3]); //校验
Set_GroupSend(SendData,10,1,BUSSend_ValidTime3,20); //组包
}
/**************************************************************************
* IrSend_Rs485_Pro
* 描述 ：红外转发接收处理函数
* 输入 ：
* RecData 接收数据
* Len 数据长度
* 输出 ：无
* 调用 ：无
*************************************************************************/
U8_T IrSend_Rs485_Pro(U8_T *RecData, U16_T Len)
{
U8_T ret = 0;
U16_T Crc_buf; //正确报文校验保存
if(0x0D != Len)
{
return 0x01;
}
if((0x55 != RecData[0]) || (0x55 != RecData[1])|| (0xee != RecData[2]) )
{
return 0x02;
}
if( (g_Dip.DIP_addr != RecData[6])&&(0xFF != RecData[6]) )
{
return 0x03;
}
if( (RecData[3] + 3 != Len) || (Tem_Type != RecData[4]))
{
return 0x04;
}
Crc_buf = GetCRC16(&RecData[3], RecData[3]-2);
if(Crc_buf == (RecData[Len-2]+(RecData[Len-1]<<8))) //校验通过
{
//控制空调
if(0x01 == RecData[5])
{
//设置温度命令
if((TEM_MIN_SET <= RecData[7]) && (RecData[7] < TEM_MAX_SET)) //在指定温度范围内
{
TempCtrl.TemState_Now.set_t = (RecData[7]&0x1f);
}else if(RecData[7] == TEM_MAX_SET){
TempCtrl.TemState_Now.set_t = (RecData[7]&0x20);
}
switch(RecData[8])
{
case 0x00:
TempCtrl.TemState_Now.on_off = TEMP_OFF; //关机
break;
case 0x01:
TempCtrl.TemState_Now.on_off = TEMP_ON; //开机
break;
default:
break; //报文有误
}
switch(RecData[9]) //风速
{
case 0x03:
TempCtrl.TemState_Now.fan = FAN_HIGH; //高风速
break;
case 0x02:
TempCtrl.TemState_Now.fan = FAN_MID; //中风速
break;
case 0x01:
TempCtrl.TemState_Now.fan = FAN_LOW; //低风速
break;
case 0x00:
TempCtrl.TemState_Now.fan = FAN_STOP; //低风速
break;
default:
break;
}
switch(RecData[10]) //
{
case 0x00:
TempCtrl.TemState_Now.mode = MODEL_COLD; //制冷
break;
case 0x01:
TempCtrl.TemState_Now.mode = MODEL_HOT; //制热
break;
case 0x02:
TempCtrl.TemState_Now.mode = MODEL_WIND; //送风
break;
default:
break;
}
Rs485AskCtrlSend(RecData);
return 0x00;
}
}
return 0x01;
}