Boonlive_RD_Embedded/RCU_C1P_Module
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
RCU_C1P_Module/MCU_Driver/blv_dev_action.c
caocong d2d8800788 feat:新建项目文件 
BLV主机C1P模块
2025-12-06 13:49:01 +08:00

3038 lines
151 KiB
C
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/*
* blv_dev_action.c
*
* Created on: Nov 11, 2025
* Author: cc
*/
#include "includes.h"
BLV_DevAction_Manage_G DevActionGlobal; //设备信息全局变量
#define Action_Group_Ctrl_Num 30 //动作数据中单个类型 群控个数上限
/*******************************************************************************
* Function Name : Expand_And_Dimm_Action_Get
* Description : 扫描动作组中的继电器类型与调光类型的动作，将其添加到群控数组中
* 疑问点 1：这个函数是不是可以优化，目前只可以群控继电器类型与调光类型的动作数据
* 疑问点 2：群控数组是不是可以使用同一个，继电器类型与调光类型为啥需要分开，为啥需要这样弄 ，这个方式是不是可以优化
* 调光类型与继电器类型分开，这样遍历的话，只需遍历一遍。。。。。。但是后面还有一次遍历
* Input :
* DevActionInfo - 动作组信息
* expand_type - 继电器群控数组
* dimm_type - 调光群控数组
* on_off - 群控状态
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void Expand_And_Dimm_Action_Get(DEV_ACTION_INFO *DevActionInfo,EXPAND_TYPE_G *expand_type,DIMM_TYPE_G *dimm_type,uint8_t on_off)
{
uint8_t TNum = 0x00; //地址相同计数
uint8_t i = 0x00,j = 0x00;
uint8_t expandexnum=0; //继电器存在计数
#if RS485_LED_Flag
uint8_t dimmexnum=0; //调光存在计数
#endif
for(i = 0; i < DevActionInfo->DevCtrlNum; i++ )
{
//遍历继电器 状态
if( (expandexnum == 0) && (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType == Dev_Host_HVout) )
{
expand_type[expandexnum].Addr = DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr;
expandexnum++;
}else if( (expandexnum > 0) && (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType == Dev_Host_HVout) )
{
for(j = 0; j <= expandexnum; j++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == expand_type[j].Addr)
{
TNum++;
break;
}
}
if(TNum == 0x00)
{
expand_type[expandexnum].Addr = DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr;
expandexnum++;
}
else if(TNum > 0)
{
TNum = 0x00;
}
}
#if RS485_LED_Flag
//遍历调光设备 状态
if( (dimmexnum == 0x00) && (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType == DEV_RS485_PWM) )
{
dimm_type[dimmexnum].Addr = DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr;
dimmexnum++;
}
else if( (dimmexnum > 0) && (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType == DEV_RS485_PWM) )
{
for(j = 0; j <= dimmexnum; j++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == dimm_type[j].Addr)
{
TNum++;
break;
}
}
if(TNum == 0x00)
{
dimm_type[dimmexnum].Addr = DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr;
dimmexnum++;
}
else if(TNum > 0)
{
TNum = 0x00;
}
}
#endif
}
for(i = 0; i < DevActionInfo->DevCtrlNum; i++) //第一次遍历，将相同的设备放到一起
{
if( DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont == 0x00 ) //立即执行才参与判断
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType == Dev_Host_HVout)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop < HVoutNumMAX)
{
for(j = 0 ; j < Action_Group_Ctrl_Num; j++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == expand_type[j].Addr)
{
expand_type[j].ExpandReadFlag|= 0x01<<DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop; //控制标志位 - 置位
if(on_off == 0x01)
{
expand_type[j].ExpandReadState[DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop]= DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState;
}else if(on_off == 0x00)
{
expand_type[j].ExpandReadState[DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop]= DEV_CTRLWAY_CLOSE;
}
}
}
}
}
#if RS485_LED_Flag
else if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType == DEV_RS485_PWM)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop < LED_OUT_CH_MAX)
{
for(j = 0; j < Action_Group_Ctrl_Num; j++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == dimm_type[j].Addr)
{
dimm_type[j].DimmReadFlag |= 0x01<<DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop;
if(on_off == 0x01)
{
dimm_type[j].DimmReadState[DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop] = DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState;
}else if(on_off == 0x02)
{
dimm_type[j].DimmReadState[DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop] = DEV_CTRLWAY_CLOSE;
}
}
}
}
}
#endif
}
}
}
/*******************************************************************************
* Function Name : RcuLockState_Scan
* Description : RCU锁定状态扫描 - 从正常到授权，取电服务会关闭
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void RcuLockState_Scan(void)
{
uint8_t LockState;
LockState = Get_Authorize_Lock_Status(); //拿到RCU的锁状态 1，锁定 0，正常
if(DevActionGlobal.DevActionU64Cond.RcuLockState != LockState)
{
DevActionGlobal.DevActionU64Cond.RcuLockState = LockState; //同步
switch(DevActionGlobal.DevActionU64Cond.RcuLockState)
{
case 0x01: //锁定
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"RCU已锁定，导致取电服务关闭");
//Ele_Ctrl_OpenClose(0x02); //断电
break;
case 0x00: //正常
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"RCU已解锁，欢迎正常使用");
break;
}
}
}
/*******************************************************************************
* @Function Name : CondJudge
* @Description : 单个条件判断
* @Input :
* State1 ： 动作中的条件，0x00 不判断，其他值:判断条件值
* State2 ：实际条件状态值
* @Return ：1条件满足 0条件不满足
*******************************************************************************/
__attribute__((section(".non_0_wait"))) uint8_t CondJudge(uint8_t State1, uint8_t State2)
{
if( (0x00 == State1) || ( (0x00 != State1) && (State1 == State2) ))
{
return CondIsPass;
}else{
return CondIsNotPass;
}
}
/*******************************************************************************
* @Function Name : BLV_DevAction_Cond_Judge
* @Description : 设备动作条件判断函数
* @Input :
* DevActionAddr : 设备动作地址
* @Return ：1条件满足 0条件不满足 主要两种条件 全局条件有8位 普通条件56位
* @Attention : 判断8个字节的条件，满足就返回1，不满足就返回0
*******************************************************************************/
__attribute__((section(".non_0_wait"))) uint8_t BLV_DevAction_Cond_Judge(DEV_ACTION_INFO *DevActionInfo)
{
if(0x01 == DevActionInfo->DevActionCond.DevActionU64Cond.DevActionOutFlag)
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"动作已锁定");
return CondIsNotPass; //锁定，直接返回条件不成立
}
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.RoomState, DevActionGlobal.DevActionU64Cond.RoomState)){Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"房态未判断通过"); return CondIsNotPass; } //房态
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.EleState, DevActionGlobal.DevActionU64Cond.EleState)){Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"取电未判断通过"); return CondIsNotPass; } //取电
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.DndState, DevActionGlobal.DevActionU64Cond.DndState)) {Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"勿扰未判断通过"); return CondIsNotPass; } //勿扰
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.CleanState, DevActionGlobal.DevActionU64Cond.CleanState)){Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"清理未判断通过"); return CondIsNotPass; } //清理
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.CallState, DevActionGlobal.DevActionU64Cond.CallState)) {Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"呼叫未判断通过"); return CondIsNotPass; } //呼叫
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.WashState, DevActionGlobal.DevActionU64Cond.WashState)) {Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"洗衣未判断通过"); return CondIsNotPass; } //洗衣
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.CheckOutState, DevActionGlobal.DevActionU64Cond.CheckOutState)) {Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"退房未判断通过"); return CondIsNotPass; } //退房
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.WaitState, DevActionGlobal.DevActionU64Cond.WaitState)) {Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"稍后未判断通过"); return CondIsNotPass; } //稍后
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.SosState, DevActionGlobal.DevActionU64Cond.SosState)) {Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"SOS未判断通过"); return CondIsNotPass; } //SOS
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.RentState, DevActionGlobal.DevActionU64Cond.RentState)) {Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"预约待租未判断通过"); return CondIsNotPass; } //预约待租
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.LockState, DevActionGlobal.DevActionU64Cond.LockState)) {Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"开锁未判断通过"); return CondIsNotPass; } //开锁
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.LuggageState, DevActionGlobal.DevActionU64Cond.LuggageState)) {Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"行李未判断通过"); return CondIsNotPass; } //行李
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.StrongState, DevActionGlobal.DevActionU64Cond.StrongState)) {Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"保险箱未判断通过"); return CondIsNotPass; } //保险箱
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.DoorState, DevActionGlobal.DevActionU64Cond.DoorState)) {Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"门磁未判断通过"); return CondIsNotPass; } //门磁
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.SeasonState, DevActionGlobal.DevActionU64Cond.SeasonState)) {Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"季节未判断通过"); return CondIsNotPass; } //季节
if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.TimeState, DevActionGlobal.DevActionU64Cond.TimeState)) {Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"时间未判断通过"); return CondIsNotPass; } //时间
// if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.NeightFlag, DevActionInfo->DevActionCond.DevActionU64Cond.NeightState, DevActionGlobal.DevActionU64Cond.NeightState)){Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"起夜未判断通过"); return CondIsNotPass; } //起夜
// if(CondIsNotPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.RcuLockState, DevActionGlobal.DevActionU64Cond.RcuLockState)) {Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"授权条件未判断通过,场景名:%s",DevActionInfo->DevActionCore.DevActionName); return CondIsNotPass; } //锁定 DevActionGlobal.DevActionU64Cond.RcuLockState
if( (0x00 != DevActionInfo->DevActionCond.DevActionU64Cond.RcuLockState)
&& ( ((0x01 == DevActionInfo->DevActionCond.DevActionU64Cond.RcuLockState)&&(0x00 == DevActionGlobal.DevActionU64Cond.RcuLockState))
||((0x02 == DevActionInfo->DevActionCond.DevActionU64Cond.RcuLockState)&&(0x01 == DevActionGlobal.DevActionU64Cond.RcuLockState) ) ) )
{
//锁定
Dbg_Println(DBG_BIT_ActCond_STATUS_bit,"授权条件未判断通过,场景名:%s",DevActionInfo->DevActionCore.DevActionName);
return CondIsNotPass;
}
return CondIsPass;
}
/*******************************************************************************
* Function Name : Expand_State_Get
* Description : 扩展场景状态得到函数 遍历所有该场景下的所有回路状态
* 待优化： 优化思路，
* 1、群控的目的是为了减少从外部SRAM读取设备数据，这样虽然减少了读取设备数据，但是增加了，大量的临时变量
* 2、这个函数的目的是遍历当前场景下所有动作回路的状态，从而判断当前场景状态是开还是关；但是每个设备状态都不一样，还有部分特殊逻辑在这里转换
* 比如窗帘状态判断，色温状态判断。。。。
* 这些判断应该由设备驱动完成，不应该由设备动作执行来转换
* 疑问点：
* if(DevActionInfo->DevActionCond.SceneExcute != ACTION_SCENE_SLEEP) 这个判断作用是什么，为什么睡眠模式下不判断
* Input :
DevActionInfo : 设备动作信息结构体
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void Expand_State_Get(DEV_ACTION_INFO *DevActionInfo)
{
uint8_t i = 0x00,j = 0x00;
uint32_t DevAddrOut = 0x00; //设备地址局部变量
uint8_t DevCtrlWay = 0x00; //执行方式
uint8_t DevCtrlCont = 0x00; //执行内容
uint8_t SceneState = DEV_STATE_OPEN;
uint8_t SceneType = 0x01;
Device_Public_Information_G BUS_Public;
EXPAND_TYPE_G expand_type[Action_Group_Ctrl_Num]={0};
DIMM_TYPE_G dimm_type[Action_Group_Ctrl_Num]={0};
Expand_And_Dimm_Action_Get(DevActionInfo,expand_type,dimm_type,0x01); //将继电器类型与调光类型的动作先挑出来
/*
* 1、先会循环动作中的继电器类型与调光类型，有多少个动作会循环多少次
* 2、当判断到继电器类型或调光类型时，还需要循环30次群动作，找到当前动作对应的群控制
* */
for(i = 0; i < DevActionInfo->DevCtrlNum; i++ )
{
if(DevActionInfo->DevActionOutput[i].DevActionOutAddr != 0x00)
{
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType)
{
case Dev_Host_HVout: //继电器设备类型
for(j = 0;j < Action_Group_Ctrl_Num;j++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == expand_type[j].Addr)
{
if(expand_type[j].ExpandReadFlag != 0x00)
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevActionInfo->DevActionOutput[i].DevActionOutAddr); //拷贝所有共有数据
if(NULL != BUS_Public.DevFunInfo.Dev_Output_Loop_Group_State_Get_ptr)
{
if(DEV_STATE_CLOSE == BUS_Public.DevFunInfo.Dev_Output_Loop_Group_State_Get_ptr(DevActionInfo->DevActionOutput[i].DevActionOutAddr, SceneType, expand_type[j].ExpandReadFlag, HVoutNumMAX, expand_type[j].ExpandReadState))
{
SceneState = DEV_STATE_CLOSE;
}
}
expand_type[j].ExpandReadFlag=0x00; //将读取标志位清零，后续如果有相同的地址，便不在进行判断了
}
break; //找到设备动作对应的群地址了 ,直接退出
}
}
break;
#if RS485_LED_Flag
case DEV_RS485_PWM: //调光设备类型
for(j = 0;j < Action_Group_Ctrl_Num; j++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == expand_type[j].Addr)
{
if(0x00!=dimm_type[j].DimmReadFlag)
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevActionInfo->DevActionOutput[i].DevActionOutAddr); //拷贝所有共有数据
if(NULL != BUS_Public.DevFunInfo.Dev_Output_Loop_Group_State_Get_ptr)
{
if(DEV_STATE_CLOSE == BUS_Public.DevFunInfo.Dev_Output_Loop_Group_State_Get_ptr(DevActionInfo->DevActionOutput[i].DevActionOutAddr, SceneType, dimm_type[j].DimmReadFlag, LED_OUT_CH_MAX, dimm_type[j].DimmReadState))
{
SceneState = DEV_STATE_CLOSE;
}
}
dimm_type[j].DimmReadFlag = 0x00; //将读取标志位清零，后续如果有相同的地址，便不在进行判断了
}
break; //找到设备动作对应的群地址了 ,直接退出
}
}
break;
#endif
}
}
}
for(i = 0;i < DevActionInfo->DevCtrlNum; i++)
{
//判断动作无延时，且动作对应的设备地址非空
if( (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont == 0x00)
&& (DevActionInfo->DevActionOutput[i].DevActionOutAddr != 0x00 ) )
{
switch( DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType )
{
case Dev_Host_LVoutput:
case DEV_RS485_SWT:
case Dev_Host_Service:
case Dev_Scene_Restore:
if(DevActionInfo->DevActionCond.SceneExcute != ACTION_SCENE_SLEEP)
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut); //读取设备公共信息
if(BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get != 0x00)
{
DevCtrlWay = (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState)&0x00ff;
if( (DevCtrlWay == DEV_CTRLWAY_OPEN) || (DevCtrlWay == DEV_CTRLWAY_CLOSE) || (DevCtrlWay == DEV_CTRLWAY_STOP) )
{
if(BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get(DevAddrOut, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop) != DevCtrlWay)
{
SceneState = DEV_STATE_CLOSE;
break;
}
}
}
}
break;
#if RS485_PB20_Relay_Flag
case Dev_Rs485_PB20_Relay:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get != 0x00)
{
DevCtrlWay = (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState)&0x00ff;
if( (DevCtrlWay == DEV_CTRLWAY_OPEN) || (DevCtrlWay == DEV_CTRLWAY_CLOSE) || (DevCtrlWay == DEV_CTRLWAY_STOP) )
{
if(BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get(DevAddrOut, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop) != DevCtrlWay)
{
SceneState = DEV_STATE_CLOSE;
break;
}
}
}
break;
#endif
case Dev_NodeCurtain: //虚拟设备 - 窗帘
case DEV_RS485_CURTAIN: //RS485设备 - 窗帘
if(DevActionInfo->DevActionCond.SceneExcute != ACTION_SCENE_SLEEP)
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get != 0x00)
{
DevCtrlWay = (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState)&0x00ff;
if( (DevCtrlWay == DEV_CTRLWAY_OPEN) \
|| (DevCtrlWay == DEV_CTRLWAY_CLOSE) \
|| (DevCtrlWay == DEV_CTRLWAY_STOP) \
|| (DevCtrlWay == 0x15) \
|| (DevCtrlWay == 0x16) )
{
if( BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get(DevAddrOut, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop) != DevCtrlWay)
{
SceneState = DEV_STATE_CLOSE;
break;
}
}else if( (DevCtrlWay == CFG_Dev_CtrlWay_Is_TOGGLE) || (DevCtrlWay == 0x05) )
{
if( BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get(DevAddrOut, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop) != DEV_CTRLWAY_STOP)
{
SceneState = DEV_STATE_CLOSE;
break;
}
}
}
}
break;
#if Dev_Nor_ColorTemp
case Dev_Nor_ColorTemp:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get != 0x00)
{
DevCtrlWay = (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState)&0x00ff;
DevCtrlCont = ((DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState)>>8)&0x00ff;
if(DevCtrlWay == DEV_CTRLWAY_OPEN)
{
DevCtrlCont |= 0x80;
if( BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get(DevAddrOut, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop) != DevCtrlCont )
{
SceneState = DEV_STATE_CLOSE;
break;
}
}else if(DevCtrlWay == DEV_CTRLWAY_CLOSE)
{
if( BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get(DevAddrOut, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop) != (DevCtrlCont & 0x80) )
{
SceneState = DEV_STATE_CLOSE;
break;
}
}
}
break;
#endif
case DEV_C5MUSIC_Type:
if(DevActionInfo->DevActionCond.SceneExcute != ACTION_SCENE_SLEEP)
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get != 0x00)
{
DEV_MUSIC_CTRLSTATE DevMusicCtrlState;
BLV_Music_CtrlState_Get(&DevMusicCtrlState,DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
if(DevMusicCtrlState.DevMusicCtrlWay.CtrlDirect == 0x00) //疑问点 - 不太清楚这个
{
DevCtrlWay = DevMusicCtrlState.DevMusicCtrlWay.CtrlDir;
if( (DevCtrlWay == DEV_CTRLWAY_OPEN) \
|| (DevCtrlWay == DEV_CTRLWAY_CLOSE) )
{
if(DevCtrlWay != BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get(DevAddrOut, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop))
{
SceneState = DEV_STATE_CLOSE;
break;
}
}
}
}
}
break;
#if Dev_Nor_Carbon_Flag
case DEV_Carbon_Saved:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut); //拷贝所有共有数据
if(NULL != BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get) //非空
{
DevCtrlWay = (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState)&0x00ff; //低字节
DevCtrlCont = ((DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState)>>8)&0x00ff; //高字节
if(0x01 == DevCtrlWay) //且控制节能状态 开和关
{
if(DevCtrlCont != BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get(DevAddrOut, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop))
{
SceneState = DEV_STATE_CLOSE; //只要有一个状态不满足就跳出 此时场景状态为关
break; //跳出switch循环
}
}
}
break;
#endif
}
}
if(SceneState == DEV_STATE_CLOSE) break;
}
if(DevActionInfo->DevActionState.SceneState != SceneState)
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit," 当前场景名:%d 场景状态:%d", DevActionInfo->DevActionCore.ActionNo, SceneState);
DevActionInfo->DevActionState.SceneState = SceneState; //1开 2关 0未初始化
}
}
/*******************************************************************************
* Function Name : Sleep_State_Get
* Description : 睡眠模式状态获取
* Input :
DevActionInfo : 设备动作信息结构体
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void Sleep_State_Get(DEV_ACTION_INFO *DevActionInfo)
{
uint8_t i;//,j;
uint32_t DevAddrOut = 0x00; //设备地址局部变量
Device_Public_Information_G BUS_Public; //共用
uint8_t DevCtrlWay = 0x00; //执行方式
uint8_t DevCtrlCont = 0x00; //执行内容
uint8_t SceneState = DEV_STATE_OPEN;
EXPAND_TYPE_G expand_type[Action_Group_Ctrl_Num]={0};
DIMM_TYPE_G dimm_type[Action_Group_Ctrl_Num]={0};
Expand_And_Dimm_Action_Get(DevActionInfo,expand_type,dimm_type,0x01);
for(i = 0; i < DevActionInfo->DevCtrlNum; i++)
{
DevAddrOut = DevActionInfo->DevActionOutput[i].DevActionOutAddr;
if(DevActionInfo->DevActionOutput[i].DevActionOutAddr != 0x00)
{
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType)
{
case Dev_Host_HVout: //继电器
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get != 0x00)
{
if(BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get(DevAddrOut, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop) == DEV_STATE_OPEN)
{
SceneState = DEV_STATE_CLOSE; //只赋值关
break;
}
}
break;
#if RS485_LED_Flag
case DEV_RS485_PWM:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get != 0x00)
{
if(BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get(DevAddrOut, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop) != 0x00)
{
SceneState = DEV_STATE_CLOSE;
break;
}
}
break;
#endif
}
}
}
for(i = 0; i < DevActionInfo->DevCtrlNum; i++ )
{
if( (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont == 0x00)
&& (DevActionInfo->DevActionOutput[i].DevActionOutAddr != 0x00) )
{
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType)
{
case Dev_Rs485_PB20_Relay:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if( BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get != 0x00)
{
DevCtrlWay = (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState)&0x00ff;
if( (DevCtrlWay == DEV_CTRLWAY_OPEN) || (DevCtrlWay == DEV_CTRLWAY_CLOSE) || (DevCtrlWay == DEV_CTRLWAY_STOP) )
{
if( BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get(DevAddrOut, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop) != DevCtrlWay )
{
SceneState = DEV_STATE_CLOSE;
break;
}
}
}
break;
case Dev_Rs485_PB20:
case Dev_Rs485_PB20_LD:
case Dev_Rs485_PB20_LS:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if( BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get != 0x00 )
{
DevCtrlWay = (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState & 0x00ff);
DevCtrlCont = ((DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState) >> 8) & 0x00ff;
//待完成 -
}
break;
case DEV_Virtual_ColorTemp:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get != 0x00)
{
DevCtrlWay = (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState)&0x00ff;
DevCtrlCont = ((DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState)>>8)&0x00ff;
if( (DevCtrlWay == DEV_CTRLWAY_OPEN) || (DevCtrlWay == DEV_CTRLWAY_CLOSE) )
{
if( BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get(DevAddrOut, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop) != DevCtrlCont )
{
SceneState = DEV_STATE_CLOSE;
break;
}
}
}
break;
}
}
if(DEV_STATE_CLOSE == SceneState) break;
}
if(DevActionInfo->DevActionState.SceneState != SceneState)
{
DevActionInfo->DevActionState.SceneState = SceneState;
}
}
/*******************************************************************************
* Function Name : MainSwitch_Expand_State_Get
* Description : 总开关扩展场景状态得到函数
* 注意:总开关场景，仅判断开的灯，有一个灯开，场景状态为开。全关才算关
* Input :
DevActionInfo : 设备动作信息结构体
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void MainSwitch_Expand_State_Get(DEV_ACTION_INFO *DevActionInfo)
{
uint8_t i = 0,j = 0;
uint32_t DevAddrOut = 0x00;
Device_Public_Information_G BUS_Public; //共用
uint8_t DevCtrlWay = 0x00; //执行方式
uint8_t DevCtrlCont = 0x00; //执行内容
uint8_t SceneState = DEV_STATE_CLOSE;
EXPAND_TYPE_G expand_type[Action_Group_Ctrl_Num]={0};
DIMM_TYPE_G dimm_type[Action_Group_Ctrl_Num]={0};
Expand_And_Dimm_Action_Get(DevActionInfo,expand_type,dimm_type,0x01);
for(i = 0;i < DevActionInfo->DevCtrlNum; i++)
{
if( DevActionInfo->DevActionOutput[i].DevActionOutAddr != DevAddrOut )
{
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType)
{
case Dev_Host_HVout: //继电器
for(j = 0;j < Action_Group_Ctrl_Num; j++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == expand_type[j].Addr)
{
if(expand_type[j].ExpandReadFlag != 0x00)
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Loop_Group_State_Get_ptr != 0x00)
{
if(BUS_Public.DevFunInfo.Dev_Output_Loop_Group_State_Get_ptr(DevAddrOut, DEV_STATE_CLOSE, expand_type[j].ExpandReadFlag, HVoutNumMAX, expand_type[j].ExpandReadState) == DEV_STATE_OPEN)
{
SceneState = DEV_STATE_OPEN;
}
}
expand_type[j].ExpandReadFlag=0x00; //清楚控制标志位
}
break;
}
}
break;
#if RS485_LED_Flag
case DEV_RS485_PWM:
for(j = 0;j < Action_Group_Ctrl_Num; j++)
{
if( DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == dimm_type[j].Addr )
{
if( dimm_type[j].DimmReadFlag != 0x00 )
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if( BUS_Public.DevFunInfo.Dev_Output_Loop_Group_State_Get_ptr != 0x00 )
{
if( BUS_Public.DevFunInfo.Dev_Output_Loop_Group_State_Get_ptr(DevAddrOut, DEV_STATE_CLOSE, dimm_type[j].DimmReadFlag, LED_OUT_CH_MAX, dimm_type[j].DimmReadState) == DEV_STATE_OPEN )
{
SceneState = DEV_STATE_OPEN;
}
}
dimm_type[j].DimmReadFlag=0x00; //清楚控制标志位
}
break;
}
}
break;
#endif
}
}
}
for( i = 0; i < DevActionInfo->DevCtrlNum; i++ )
{
if( DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont == 0x00 )
{
if( DevActionInfo->DevActionOutput[i].DevActionOutAddr != 0x00 )
{
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType)
{
case DEV_RS485_STRIP:
case Dev_Rs485_PB20:
case DEV_Virtual_ColorTemp:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if( BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get != 0x00 )
{
DevCtrlWay = (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState)&0x00ff;
DevCtrlCont = ((DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState)>>8)&0x00ff;
if(DevCtrlWay == DEV_STATE_OPEN)
{
if( BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get(DevAddrOut, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop) == DevCtrlCont )
{
SceneState = DEV_STATE_OPEN;
break;
}
}
}
break;
case Dev_Scene_Restore:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if( BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get != 0x00 )
{
DevCtrlWay = (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState)&0x00ff;
if( (DevCtrlWay == DEV_STATE_OPEN) || (DevCtrlWay == DEV_STATE_CLOSE) )
{
if( BUS_Public.DevFunInfo.Dev_Output_Loop_State_Get(DevAddrOut, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop) == DevCtrlWay )
{
SceneState = DEV_STATE_OPEN;
break;
}
}
}
break;
}
}
if(SceneState == DEV_STATE_OPEN) break; //跳出for循环
}
}
DevActionInfo->DevActionState.SceneState = SceneState;
}
/*******************************************************************************
* Function Name : DevAction_State_Get
* Description : 设备动作状态得到
* Input :
DevActionInfo : 设备动作信息结构体
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void DevAction_State_Get(DEV_ACTION_INFO *DevActionInfo)
{
switch(DevActionInfo->DevActionCond.SceneExcute) //根据动作当前的执行方式
{
case ACTION_SCENE_SLEEP: //设备执行方式 - 睡眠模式
if(DevActionGlobal.DevActionU64Cond.NeightFlag == 0x01) //夜灯存在
{
if(DevActionGlobal.DevActionU64Cond.NeightState == NightModeStart) //进入起夜场景 赋值给全局动作变量
{
DevActionInfo->DevActionState.SceneState = DEV_STATE_OPEN; //起夜场景 - 开
if( DevActionGlobal.SleepLight_State != 0x01 )
{
DevActionGlobal.SleepMode_State = 0x01;
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"进入睡眠场景 5");
}
}
if(DevActionGlobal.CardInFlag == 0x01) //入住服务标志位开启 - 清除睡眠标志位
{
Sleep_State_Get(DevActionInfo);
if(DevActionInfo->DevActionState.SceneState == DEV_STATE_CLOSE) //当前场景 夜灯存在的话,场景为关时，关闭睡眠模式 - 疑问点
{
DevActionGlobal.CardInFlag = 0x00;
DevActionGlobal.SleepMode_State = 0x00;
DevActionGlobal.DevActionU64Cond.NeightState = NightModeClose;
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"退出睡眠场景 -5");
}
}
break; //带夜灯 直接跳出
}else {
Expand_State_Get(DevActionInfo);
if(DevActionInfo->DevActionState.SceneState == DEV_STATE_CLOSE)
{
if(DevActionGlobal.CardInFlag == 0x01)
{
DevActionGlobal.CardInFlag = 0x00;
DevActionGlobal.SleepMode_State = 0x00;
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"退出睡眠场景 -6");
}
}
}
break;
case ACTION_SCENE_ONE: //设备执行方式 - 不可关闭
case ACTION_SCENE_TWO: //设备执行方式 - 可关闭
case ACTION_SCENE_HELPSLEEP: //设备执行方式 - 助眠场景
Expand_State_Get(DevActionInfo);
break;
case ACTION_SCENE_MAINSWITCH: //设备执行方式 - 总开关
MainSwitch_Expand_State_Get(DevActionInfo); //场景状态得到
break;
}
if( DevActionGlobal.DevActionU64Cond.NeightState != DevActionGlobal.Last_NeightState )
{
DevActionGlobal.Last_NeightState = DevActionGlobal.DevActionU64Cond.NeightState;
}
}
/*******************************************************************************
* Function Name : DevDly_InfoSet
* Description : 延时动作执行，信息直接赋值
* Input :
DevDlyAddr : 延时链表的节点地址
DlyExcuteFlag ：延时执行标志
DevOutputType ：执行方式
DevDelayTime ：执行时间
DlyBlinkFlag ：闪烁标志位
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void DevDly_InfoSet(
uint32_t DevDlyAddr,
uint8_t DlyExcuteFlag,
uint16_t DevOutputType,
Dev_Dly_Value DevDelayTime,
uint8_t DlyBlinkFlag)
{
Struct_Dev_Dly DevDlyInfo;
Dev_Dly_Value DevDlyValue;
uint32_t DlyExcuteTime = 0x00;
if( DevDlyAddr == 0x00 ) return ;
DevDlyValue.DelayCont = DevDelayTime.DelayCont;
DevDlyValue.DelayWeight = DevDelayTime.DelayWeight;
switch(DevDlyValue.DelayWeight)
{
case 0x00: //单位为0，可能准备清延时
DlyExcuteTime = 0x00;
break;
case DELAY_TIME_MS: //0x01 //毫秒
DlyExcuteTime = SysTick_1ms + DevDlyValue.DelayCont;
break;
case DELAY_TIME_S: //0x02 //秒
DlyExcuteTime = SysTick_1ms + DevDlyValue.DelayCont*1000;
break;
case DELAY_TIME_MIN: //0x03 //分钟
DlyExcuteTime = SysTick_1ms + DevDlyValue.DelayCont*1000*60;
break;
case DELAY_TIME_HOUR: //0x04 //小时
DlyExcuteTime = SysTick_1ms + DevDlyValue.DelayCont*1000*60*60;
break;
default:
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"延时单位为无效:", DevDlyValue.DelayWeight);
return; //其他情况直接返回
}
SRAM_DMA_Read_Buff((uint8_t *)&DevDlyInfo, sizeof(Struct_Dev_Dly), DevDlyAddr); //把状态读取出来
if( ( DevDlyInfo.DlyExcuteTime != DlyExcuteTime )
|| ( DevDlyInfo.DlyExcuteFlag != DlyExcuteFlag )
|| ( DevDlyInfo.DevOutputType != DevOutputType )
|| ( DevDlyInfo.DlyBlinkFlag != DlyBlinkFlag )
|| ( DevDlyInfo.DlyBlinkTime.DelayCont != DevDelayTime.DelayCont )
|| ( DevDlyInfo.DlyBlinkTime.DelayWeight != DevDelayTime.DelayWeight ) )
{
DevDlyInfo.DlyExcuteFlag = DlyExcuteFlag;
DevDlyInfo.DevOutputType = DevOutputType;
switch(DlyBlinkFlag)
{
case 0x01: //开启闪烁
DevDlyInfo.DlyBlinkFlag = DlyBlinkFlag;
DevDlyInfo.DlyExcuteTime = DlyExcuteTime;
break;
case 0x02: //关闭闪烁 不重新赋值倒计时时间
if(0x01 == DevDlyInfo.DlyBlinkFlag) //之前是开启闪烁状态
{
DevDlyInfo.DlyBlinkFlag = DlyBlinkFlag;
}
break;
default:
DevDlyInfo.DlyBlinkFlag = DlyBlinkFlag;
DevDlyInfo.DlyExcuteTime = DlyExcuteTime;
break;
}
DevDlyInfo.DlyBlinkTime.DelayCont = DevDelayTime.DelayCont;
DevDlyInfo.DlyBlinkTime.DelayWeight = DevDelayTime.DelayWeight;
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"延时节点赋值，节点地址:%08X 执行标志:%d 时间:%02x%02x, 执行方式:%04X 闪烁标志:%d", \
DevDlyAddr, DlyExcuteFlag, \
DevDlyValue.DelayCont, \
DevDlyValue.DelayWeight, \
DevOutputType, \
DevDlyInfo.DlyBlinkFlag);
SRAM_DMA_Write_Buff((uint8_t *)&DevDlyInfo, sizeof(Struct_Dev_Dly), DevDlyAddr); //把状态读取出来
}
}
/*******************************************************************************
* Function Name : DevDlyAddr_Get
* Description : 根据设备信息和回路，来得到延时节点
* Input :
DevDlyAddr : 延时链表的节点地址
DevOutputLoop ：延时输出回路
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) uint32_t DevDlyAddr_Get(uint32_t DevDlyAddr, uint16_t DevOutputLoop)
{
uint16_t i = 0x00;
uint32_t list_addr = 0x00;
Struct_Dev_Dly_Core DevDlyCore;
for(i = 0; i < DevActionGlobal.DevDlyNum; i++)
{
list_addr = SRAM_DevDly_List_Start_Addr + i * DevDlyStructLen;
SRAM_DMA_Read_Buff((uint8_t *)&DevDlyCore, sizeof(Struct_Dev_Dly_Core), list_addr);
if( (DevDlyCore.DevDlyAddr == DevDlyAddr) && (DevDlyCore.DevOutputLoop == DevOutputLoop) )
{
return list_addr;
}
}
return 0x00;
}
/*******************************************************************************
* Function Name : Add_DevDly_To_List
* Description : 将延时设备信息添加到链表
* 将需要延时的节点添加到链表，如果是新节点，就返回新的地址，如果是旧节点，就返回旧地址
* Input :
DevType : 设备类型
DevDlyAddr ：设备节点地址
DevOutputLoop ：回路地址
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) uint32_t Add_DevDly_To_List(uint8_t DevType, uint32_t DevDlyAddr, uint16_t DevOutputLoop)
{
uint32_t list_addr = 0x00;
Struct_Dev_Dly_Core DevDlyCore;
if(DevActionGlobal.DevActionNum >= DevDlyNumMax) //延时设备总数超过范围就返回
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"延时设备添加超过范围 延时设备上限: %d", DevDlyNumMax);
return 0x00;
}
list_addr = DevDlyAddr_Get(DevDlyAddr, DevOutputLoop); //遍历当前所有延时节点
if(list_addr != 0x00) return list_addr; //直接将地址返回
DevDlyCore.DevType = DevType;
DevDlyCore.DevDlyAddr = DevDlyAddr;
DevDlyCore.DevOutputLoop = DevOutputLoop; //填充数据
list_addr = SRAM_DevDly_List_Start_Addr + DevActionGlobal.DevDlyNum*DevDlyStructLen;
SRAM_DMA_Write_Buff((uint8_t *)&DevDlyCore, sizeof(Struct_Dev_Dly_Core), list_addr);
DevActionGlobal.DevDlyNum++; //延时节点计数增加
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"延时设备添加成功当前延时节点地址:%08X 当前延时设备计数:%d 延时设备地址: %08X 延时设备回路：%d",
list_addr ,
DevActionGlobal.DevDlyNum,
DevDlyCore.DevDlyAddr,
DevDlyCore.DevOutputLoop);
/*遍历当前所有的延时设备，存在过的，就不添加，不存在的就往后添加*/
return list_addr; //返回有效的地址
}
/*******************************************************************************
* Function Name : DevAddrCtr
* Description : 添加设备控制
*******************************************************************************/
__attribute__((section(".non_0_wait"))) uint8_t DevAddrCtr(DEV_ACTION_INFO *DevActionInfo, uint8_t *p, uint8_t DataLen)
{
uint8_t Ret = 0x02; //默认不存在
uint32_t DevAddrOut = 0x00; //设备地址局部变量
Dev_Action_Output DevActionOutput;
memset((uint8_t *)&DevActionOutput, 0x00, sizeof(Dev_Action_Output));
switch(DataLen)
{
case DevCtrlLen:
case DevCtrlDlyLenAddr:
memcpy((uint8_t *)&DevActionOutput, p, DataLen);
break;
default:
return Ret;
}
switch(DataLen)
{
case DevCtrlLen: //6字节 需要自己查设备
DevAddrOut = Find_AllDevice_List_Information(DevActionOutput.DevActionOutCfg.DevType, DevActionOutput.DevActionOutCfg.DevAddr);
break;
case DevCtrlDlyLenAddr: //带延时，带地址控制，带延时设备地址
DevAddrOut = DevActionOutput.DevActionOutAddr;
break;
}
if(DevAddrOut == 0x00) return Ret;
Ret = 0x01;
if( DevActionOutput.DevActionOutCfg.DevDlyValue.DelayCont == 0x00 )
{
Device_Public_Information_G BUS_Public;
DevDly_InfoSet(
DevActionOutput.DevDlyAddr,
0x00,
DevActionOutput.DevActionOutCfg.DevCtrlState,
DevActionOutput.DevActionOutCfg.DevDlyValue,
0x00);
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
switch(DevActionOutput.DevActionOutCfg.DevType)
{
case DEV_RS485_SWT:
case DEV_RS485_WxLock:
case Dev_Host_Service:
case Dev_Host_HVout:
case Dev_Host_LVoutput:
case Dev_NodeCurtain:
case DEV_RS485_CURTAIN:
case DEV_RS485_IR_SEND:
case DEV_RS485_TEMP:
case DEV_RS485_FreshAir:
case DEV_RS485_HEATER:
case Dev_Energy_Monitor:
if(BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL)
{
if( (DevActionInfo != 0x00) && (DevActionInfo->DevActionState.DevAddrIn != 0x00) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"输入设备地址:%04X 设备类型:%d 地址:%04X %d路 控制状态: %04X",
DevActionInfo->DevActionState.DevAddrIn,
DevActionOutput.DevActionOutCfg.DevType,
DevAddrOut,
DevActionOutput.DevActionOutCfg.DevOutputLoop,
DevActionOutput.DevActionOutCfg.DevCtrlState);
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionInput.inAddr,
DevAddrOut,
DevActionOutput.DevActionOutCfg.DevOutputLoop,
DevActionOutput.DevActionOutCfg.DevCtrlState);
}else {
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionOutput.DevActionOutCfg.DevOutputLoop,
DevActionOutput.DevActionOutCfg.DevCtrlState);
}
}
break;
case DEV_RS485_PWM:
case DEV_RS485_STRIP:
case Dev_Rs485_PB20:
case Dev_Rs485_PB20_LD:
case Dev_Rs485_PB20_LS:
case Dev_Rs485_PB20_Relay:
case DEV_Virtual_ColorTemp:
case Dev_Virtual_GlobalSet:
if( BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL )
{
if( (DevActionInfo != 0x00) && (DevActionInfo->DevActionState.DevAddrIn != 0x00) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"输入设备地址:%04X 设备类型:%d 地址:%04X %d路 控制状态: %04X",
DevActionInfo->DevActionState.DevAddrIn,
DevActionOutput.DevActionOutCfg.DevType,
DevAddrOut,
DevActionOutput.DevActionOutCfg.DevOutputLoop,
DevActionOutput.DevActionOutCfg.DevCtrlState);
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionInput.inAddr,
DevAddrOut,
DevActionOutput.DevActionOutCfg.DevOutputLoop,
DevActionOutput.DevActionOutCfg.DevCtrlState);
}else {
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionOutput.DevActionOutCfg.DevOutputLoop,
DevActionOutput.DevActionOutCfg.DevCtrlState);
}
}
break;
}
}else if( (DevActionOutput.DevActionOutCfg.DevDlyValue.DelayCont != 0x00) && (DevActionOutput.DevDlyAddr != 0x00) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"准备延时设备执行置位，设备类型:%d %d路 内容: %d,时间：%d单位：%d",
DevActionOutput.DevActionOutCfg.DevType,
DevActionOutput.DevActionOutCfg.DevOutputLoop,
DevActionOutput.DevActionOutCfg.DevCtrlState,
DevActionOutput.DevActionOutCfg.DevDlyValue.DelayCont,
DevActionOutput.DevActionOutCfg.DevDlyValue.DelayWeight);
DevDly_InfoSet(
DevActionOutput.DevDlyAddr,
0x01,
DevActionOutput.DevActionOutCfg.DevCtrlState,
DevActionOutput.DevActionOutCfg.DevDlyValue,
0x00);
}
return Ret;
}
/*******************************************************************************
* Function Name : DevActionCtrl
* Description : 设备控制专线
*******************************************************************************/
__attribute__((section(".non_0_wait"))) uint8_t DevActionCtrl(uint8_t *p, uint8_t DataLen)
{
uint8_t Ret = 0x02; //默认失败
uint16_t SceneCtrlNo = 0x00; //控制的场景号
uint16_t SceneCtrlState = 0x00;
if(DevCtrlLen != DataLen) return Ret;
switch(p[0])
{
case Dev_Host_Invalid:
DevActionGlobal.ServerCtrl = 0x01;
SceneCtrlNo = p[3];
SceneCtrlNo <<= 0x08;
SceneCtrlNo |= p[2];
SceneCtrlState = p[5];
SceneCtrlState <<= 0x08;
SceneCtrlState |= p[4];
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"控制场景 场景号:%d", SceneCtrlNo);
if(SceneCtrlNo == DevActionGlobal.SleepActionNo) p[4] = 0x02;
DevAction_No_Ctrl(SceneCtrlNo, 0x01, SceneCtrlState);
break;
default:
Ret = DevAddrCtr(NULL, p, DataLen);
break;
}
return Ret;
}
/*******************************************************************************
* Function Name : Ele_Ctrl_OpenClose
* Description : 单纯控制取电服务取电状态
* Input :
Ctrl : 0x01-开，0x00-关
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void Ele_Ctrl_OpenClose(uint8_t Ctrl)
{
uint8_t DataBuf[6];
DataBuf[0] = Dev_Host_Service;
DataBuf[1] = 0x00;
DataBuf[2] = 0x00;
DataBuf[3] = 0x00;
DataBuf[4] = Ctrl;
DataBuf[5] = 0x00;
DevAddrCtr(NULL, DataBuf, 0x06); //插卡取电控制
}
/*******************************************************************************
* Function Name : DevAction_ExpandCtrl
* Description : 扩展场景状态控制函数
* Input :
DevActionInfo : 设备动作信息结构体
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void DevAction_ExpandCtrl(DEV_ACTION_INFO *DevActionInfo)
{
uint8_t i = 0,j = 0;
uint32_t DevAddrOut = 0x00; //设备地址局部变量
Device_Public_Information_G BUS_Public;
EXPAND_TYPE_G expand_type[Action_Group_Ctrl_Num]={0};
DIMM_TYPE_G dimm_type[Action_Group_Ctrl_Num]={0};
Expand_And_Dimm_Action_Get(DevActionInfo,expand_type,dimm_type,0x01);
for(i = 0; i < DevActionInfo->DevCtrlNum; i++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutAddr != DevAddrOut)
{
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType)
{
case Dev_Host_HVout:
for(j = 0; j < Action_Group_Ctrl_Num; j++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == expand_type[j].Addr)
{
if( expand_type[j].ExpandReadFlag != 0x00 )
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if( BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl != 0x00 )
{
BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl(
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionInput.inAddr,
DevAddrOut,
expand_type[j].ExpandReadFlag,
HVoutNumMAX,
expand_type[j].ExpandReadState);
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"继电器状态群控控制开始，回路标志:%08X 场景名:%s ",
expand_type[j].ExpandReadFlag,
DevActionInfo->DevActionCore.DevActionName);
}
expand_type[j].ExpandReadFlag=0x00;
}
break; //处理完成，直接退出当前循环
}
}
break;
#if RS485_LED_Flag
case DEV_RS485_PWM:
for(j = 0; j < Action_Group_Ctrl_Num; j++ )
{
if( DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == dimm_type[j].Addr )
{
if( dimm_type[j].DimmReadFlag != 0x00 )
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if( BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl != 0x00 )
{
BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl(
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionInput.inAddr,
DevAddrOut,
dimm_type[j].DimmReadFlag,
LED_OUT_CH_MAX,
dimm_type[j].DimmReadState);
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"PWM调光状态群控控制开始地址:%d，回路标志:%08X 场景名:%s ",
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr,
dimm_type[j].DimmReadFlag,
DevActionInfo->DevActionCore.DevActionName);
}
dimm_type[j].DimmReadFlag = 0x00;
}
break; //处理完成，直接退出当前循环
}
}
break;
#endif
}
}
}
for(i = 0; i < DevActionInfo->DevCtrlNum ; i++ )
{
if( DevActionInfo->DevActionOutput[i].DevActionOutAddr != 0x00)
{
if( DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont == 0x00 )
{
//清延时执行标志位
DevDly_InfoSet(
DevActionInfo->DevActionOutput[i].DevDlyAddr,
0x00,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue,
0x00);
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType)
{
case DEV_RS485_SWT:
case DEV_RS485_WxLock:
case Dev_Host_Service:
case Dev_Host_LVoutput:
case Dev_NodeCurtain:
case DEV_RS485_IR_SEND:
case DEV_RS485_TEMP:
case DEV_RS485_CURTAIN:
case DEV_RS485_FreshAir:
case DEV_RS485_HEATER:
case Dev_Rs485_PB20:
case Dev_Rs485_PB20_LD:
case Dev_Rs485_PB20_LS:
case Dev_Rs485_PB20_Relay:
case DEV_Virtual_NoCard:
case DEV_Virtual_Card:
case Dev_485_BLE_Music:
case DEV_Carbon_Saved:
case Dev_Scene_Restore:
case Dev_Energy_Monitor:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL)
{
if( (DevActionInfo != NULL) && (DevActionInfo->DevActionState.DevAddrIn != 0x00) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"输入设备地址:%04X 设备类型:%d 地址:%04X %d路 控制状态: %04X",
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState); //服务信息状态赋值
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionInput.inAddr,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
}else {
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
}
}
break;
case DEV_RS485_STRIP:
case DEV_Virtual_ColorTemp:
case Dev_Virtual_GlobalSet:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if( BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL)
{
if( (DevActionInfo != NULL) && (DevActionInfo->DevActionState.DevAddrIn != 0x00) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"输入设备地址:%04X 设备类型:%d 地址:%04X %d路 控制状态: %04X",
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState); //服务信息状态赋值
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionInput.inAddr,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
}else {
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
}
}
break;
case DEV_RS485_MUSIC:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL)
{
if( ( DevActionInfo != NULL )
&& ( CondIsPass == CondJudge(DevActionInfo->DevActionCond.DevActionU64Cond.WarningState, DevActionGlobal.DevActionU64Cond.WarningState) ) )
{
DEV_MUSIC_CTRLSTATE DevMusicCtrlState; //背景音乐控制状态
BLV_Music_CtrlState_Get(&DevMusicCtrlState,DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
switch(DevMusicCtrlState.DevMusicCtrlWay.CtrlDirect)
{
case 0x03: //场景开播放
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"准备执行背景音乐指定文件夹开播放，回路:%d 状态: %04X",DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState); //执行开场景指定播放
break;
case 0x04: //场景关播放
break;
default: //其他情况
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"准备执行背景音乐开关机模式控制，地址:%d 回路:%d状态: %04X",BUS_Public.addr, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState); //执行开场景指定播放
break;
}
}
}
break;
}
}
else if( ( 0x00 != DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont )
&& ( 0x00 != DevActionInfo->DevActionOutput[i].DevDlyAddr ) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"准备延时设备执行置位，设备类型:%d %d路 内容: %d,时间：%d单位：%d",
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayWeight);
DevDly_InfoSet(
DevActionInfo->DevActionOutput[i].DevDlyAddr,
0x01,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue,
0x00);
}
}
}
}
/*******************************************************************************
* Function Name : DevAction_ExpandLightOpen
* Description : 扩展灯光类设备控制函数 或者场景
* Input :
DevActionInfo : 设备动作信息结构体
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void DevAction_ExpandLightOpen(DEV_ACTION_INFO *DevActionInfo)
{
uint8_t i = 0,j = 0;
uint32_t DevAddrOut = 0;
Device_Public_Information_G BUS_Public;
EXPAND_TYPE_G expand_type[Action_Group_Ctrl_Num]={0};
DIMM_TYPE_G dimm_type[Action_Group_Ctrl_Num]={0};
Expand_And_Dimm_Action_Get(DevActionInfo,expand_type,dimm_type,0x01);
for(i = 0; i < DevActionInfo->DevCtrlNum; i++ )
{
if(DevActionInfo->DevActionOutput[i].DevActionOutAddr != 0x00)
{
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType)
{
case Dev_Host_HVout:
for(j = 0; j < Action_Group_Ctrl_Num; j++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == expand_type[j].Addr)
{
if( expand_type[j].ExpandReadFlag != 0x00 )
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if( BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl != NULL )
{
BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl(
0x00,
0x00,
DevAddrOut,
expand_type[j].ExpandReadFlag,
HVoutNumMAX,
expand_type[j].ExpandReadState);
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"继电器群控控制，回路标志:%08X 场景名:%s ",
expand_type[j].ExpandReadFlag,
DevActionInfo->DevActionCore.DevActionName);
}
expand_type[j].ExpandReadFlag=0x00;
}
break;
}
}
break;
#if RS485_LED_Flag
case DEV_RS485_PWM:
for(j = 0; j < Action_Group_Ctrl_Num; j++)
{
if( DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == dimm_type[j].Addr )
{
if( dimm_type[j].DimmReadFlag != 0x00 )
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl != NULL)
{
BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl(
0x00,
0x00,
DevAddrOut,
dimm_type[j].DimmReadFlag,
LED_OUT_CH_MAX,
dimm_type[j].DimmReadState);
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"PWM调光群控控制开始地址:%d，回路标志:%08X 场景名:%s ",
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr,
dimm_type[j].DimmReadFlag,
DevActionInfo->DevActionCore.DevActionName);
}
dimm_type[j].DimmReadFlag = 0x00;
}
}
}
break;
#endif
}
}
}
for(i = 0; i < DevActionInfo->DevCtrlNum; i++)
{
if( DevActionInfo->DevActionOutput[i].DevActionOutAddr == 0x00 )
{
if( DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont == 0x00 )
{
DevDly_InfoSet(DevActionInfo->DevActionOutput[i].DevDlyAddr, 0x00, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState, DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue, 0x00);
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType)
{
case Dev_Host_LVoutput:
case Dev_Rs485_PB20:
case Dev_Rs485_PB20_LD:
case Dev_Rs485_PB20_LS:
case Dev_Rs485_PB20_Relay:
case Dev_Scene_Restore:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL)
{
if( (DevActionInfo != 0x00) && (DevActionInfo->DevActionState.DevAddrIn != 0x00) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"输入设备地址:%04X 设备类型:%d 地址:%04X %d路 控制状态: %04X",
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionInput.inAddr,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
}else{
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
}
}
break;
case DEV_RS485_STRIP:
case DEV_Virtual_ColorTemp:
case Dev_Virtual_GlobalSet:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if( BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL )
{
if( (DevActionInfo != 0x00) && (DevActionInfo->DevActionState.DevAddrIn != 0x00) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"输入设备地址:%04X 设备类型:%d 地址:%04X %d路 控制状态: %04X",
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionInput.inAddr,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
}else {
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
}
}
break;
}
}else if( (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont != 0x00) && (DevActionInfo->DevActionOutput[i].DevDlyAddr != 0x00) )
{
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType)
{
case Dev_Host_HVout:
case Dev_Host_LVoutput:
case DEV_RS485_PWM:
case DEV_RS485_STRIP:
case DEV_Virtual_ColorTemp:
case Dev_Scene_Restore:
case Dev_Virtual_GlobalSet:
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"准备延时设备执行置位，设备类型:%d %d路 内容: %d,时间：%d单位：%d",
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayWeight);
DevDly_InfoSet(DevActionInfo->DevActionOutput[i].DevDlyAddr,
0x01,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue,
0x00);
break;
}
}
}
}
}
/*******************************************************************************
* Function Name : DevAction_ExpandLightClose
* Description : 扩展场景状态控制函数 立即执行的设备才执行 所有设备都关闭
* Input :
DevActionInfo : 设备动作信息结构体
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void DevAction_ExpandLightClose(DEV_ACTION_INFO *DevActionInfo)
{
uint8_t i = 0x00,j = 0x00;
uint32_t DevAddrOut = 0x00;
Device_Public_Information_G BUS_Public;
EXPAND_TYPE_G expand_type[Action_Group_Ctrl_Num]={0};
DIMM_TYPE_G dimm_type[Action_Group_Ctrl_Num]={0};
Expand_And_Dimm_Action_Get(DevActionInfo,expand_type,dimm_type,0x00);
for(i = 0; i < DevActionInfo->DevCtrlNum; i++ )
{
if(DevActionInfo->DevActionOutput[i].DevActionOutAddr != 0x00)
{
switch( DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType )
{
case Dev_Host_HVout:
for(j = 0; j < Action_Group_Ctrl_Num ; j++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == expand_type[j].Addr)
{
if(expand_type[j].ExpandReadFlag != 0x00)
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl != NULL)
{
BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl(
0x00,
0x00,
DevAddrOut,
expand_type[j].ExpandReadFlag,
HVoutNumMAX,
expand_type[j].ExpandReadState);
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"继电器状态群控控制开始，回路标志:%08X 场景名:%s ",
expand_type[j].ExpandReadFlag,
DevActionInfo->DevActionCore.DevActionName);
}
expand_type[j].ExpandReadFlag=0x00;
}
break; //执行完成，直接退出
}
}
break;
#if RS485_LED_Flag
case DEV_RS485_PWM:
for(j = 0;j < Action_Group_Ctrl_Num; j++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == dimm_type[j].Addr)
{
if(dimm_type[j].DimmReadFlag != 0x00)
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl != NULL)
{
BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl(
0x00,
0x00,
DevAddrOut,
dimm_type[j].DimmReadFlag,
LED_OUT_CH_MAX,
dimm_type[j].DimmReadState);
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"PWM调光状态群控控制开始地址:%d，回路标志:%08X 场景名:%s ",
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr,
dimm_type[j].DimmReadFlag,
DevActionInfo->DevActionCore.DevActionName);
}
dimm_type[j].DimmReadFlag = 0x00;
}
break;
}
}
break;
#endif
}
}
}
for(i = 0; i < DevActionInfo->DevCtrlNum; i++)
{
if( DevActionInfo->DevActionOutput[i].DevActionOutAddr != 0x00 )
{
if( DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont == 0x00 )
{
DevDly_InfoSet(DevActionInfo->DevActionOutput[i].DevDlyAddr,
0x00,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue,
0x00);
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType)
{
case Dev_Host_LVoutput:
case DEV_RS485_STRIP:
case Dev_Rs485_PB20_Relay:
case DEV_Virtual_ColorTemp:
case Dev_Scene_Restore:
case Dev_Virtual_GlobalSet:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if( BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL )
{
if( (DevActionInfo != 0x00) && (DevActionInfo->DevActionState.DevAddrIn != 0x00) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"输入设备地址:%04X 设备类型:%d 地址:%04X %d路 控制状态: %04X",
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DEV_CTRLWAY_CLOSE);
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionInput.inAddr,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DEV_CTRLWAY_CLOSE);
}else {
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DEV_CTRLWAY_CLOSE);
}
}
break;
case Dev_Rs485_PB20:
case Dev_Rs485_PB20_LD:
case Dev_Rs485_PB20_LS:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if( BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL )
{
if( (DevActionInfo != 0x00) && (DevActionInfo->DevActionState.DevAddrIn != 0x00) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"输入设备地址:%04X 设备类型:%d 地址:%04X %d路 控制状态: %04X",
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
0x0012);
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionInput.inAddr,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
0x0012);
}else {
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
0x0012);
}
}
break;
}
}else if( (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont != 0x00) && (DevActionInfo->DevActionOutput[i].DevDlyAddr != 0x00) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"准备延时设备执行置位，设备类型:%d %d路 内容: %d,时间：%d单位：%d",
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayWeight);
DevDly_InfoSet(DevActionInfo->DevActionOutput[i].DevDlyAddr,
0x01,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue,
0x00);
}
}
}
}
/*******************************************************************************
* Function Name : DevAction_ExpandClose
* Description : 扩展场景状态控制函数 立即执行的设备才执行 所有设备都关闭
* Input :
DevActionInfo : 设备动作信息结构体
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void DevAction_ExpandClose(DEV_ACTION_INFO *DevActionInfo, uint8_t ModeCtrl)
{
uint8_t i = 0x00,j = 0x00;
uint32_t DevAddrOut = 0x00;
Device_Public_Information_G BUS_Public;
EXPAND_TYPE_G expand_type[Action_Group_Ctrl_Num]={0};
DIMM_TYPE_G dimm_type[Action_Group_Ctrl_Num]={0};
for(i = 0; i < DevActionInfo->DevCtrlNum; i++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutAddr != 0x00)
{
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType)
{
case Dev_Host_HVout:
for(j = 0; j < Action_Group_Ctrl_Num; j++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == expand_type[j].Addr)
{
if(expand_type[j].ExpandReadFlag != 0x00)
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl != NULL)
{
BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl(
0x00,
0x00,
DevAddrOut,
expand_type[j].ExpandReadFlag,
HVoutNumMAX,
expand_type[j].ExpandReadState);
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"继电器状态群控控制开始，回路标志:%08X 场景名:%s ",
expand_type[j].ExpandReadFlag,
DevActionInfo->DevActionCore.DevActionName);
}
expand_type[j].ExpandReadFlag=0x00;
}
break; //执行完成，直接退出
}
}
break;
#if RS485_LED_Flag
case DEV_RS485_PWM:
for(j = 0; j < Action_Group_Ctrl_Num; j++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr == dimm_type[j].Addr)
{
if(dimm_type[j].DimmReadFlag != 0x00)
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl != NULL)
{
BUS_Public.DevFunInfo.Dev_Output_Group_Ctrl(
0x00,
0x00,
DevAddrOut,
dimm_type[j].DimmReadFlag,
LED_OUT_CH_MAX,
dimm_type[j].DimmReadState);
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"PWM调光状态群控控制开始地址:%d，回路标志:%08X 场景名:%s ",
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr,
dimm_type[j].DimmReadFlag,
DevActionInfo->DevActionCore.DevActionName);
}
dimm_type[j].DimmReadFlag = 0x00;
}
break;
}
}
break;
#endif
}
}
}
for(i = 0; i < DevActionInfo->DevCtrlNum; i++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutAddr != 0x00)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont == 0x00)
{
DevDly_InfoSet(DevActionInfo->DevActionOutput[i].DevDlyAddr,
0x00,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue,
0x00);
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType)
{
case DEV_RS485_SWT:
case Dev_Host_LVoutput:
case DEV_RS485_STRIP:
case Dev_Rs485_PB20_Relay:
case DEV_Virtual_ColorTemp:
case Dev_Scene_Restore:
case Dev_Virtual_GlobalSet:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL)
{
if( (DevActionInfo != 0x00) && (DevActionInfo->DevActionState.DevAddrIn != 0x00) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"输入设备地址:%04X 设备类型:%d 地址:%04X %d路 控制状态: %04X",
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DEV_CTRLWAY_CLOSE);
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionInput.inAddr,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DEV_CTRLWAY_CLOSE);
}else {
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DEV_CTRLWAY_CLOSE);
}
}
break;
case Dev_Rs485_PB20:
case Dev_Rs485_PB20_LD:
case Dev_Rs485_PB20_LS:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL) //非空
{
if((DevActionInfo != 0x00) && (DevActionInfo->DevActionState.DevAddrIn != 0x00)) //
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"输入设备地址:%04X 设备类型:%d 地址:%04X %d路 控制状态: %04X",
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
0x0012);
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionInput.inAddr,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
0x0012);
}else{
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
0x0012);
}
}
break;
case Dev_NodeCurtain: //窗帘开取反为窗帘停 窗帘关取反为窗帘停 窗帘停取反为窗帘开或关
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut); //拷贝所有共有数据
if(BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL)
{
switch(ModeCtrl)
{
case NOR_MODE_CTRL:
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState & 0x00FF)
{
case DEV_CTRLWAY_OPEN: //开
case DEV_CTRLWAY_CLOSE: //关
case CFG_Dev_CtrlWay_Is_TOGGLE: //互切
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DEV_CTRLWAY_STOP);
break;
case 0x15: //延时控制开
case 0x16: //延时控制关 - 场景可关闭时，延时控制关闭状态为0x17
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
0x17);
break;
case DEV_CTRLWAY_STOP:
break;
}
break;
case SLEEP_MODE_CTRL:
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
break;
}
}
break;
case DEV_RS485_CURTAIN:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if( BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL )
{
switch(ModeCtrl)
{
case NOR_MODE_CTRL: //普通模式 窗帘控制
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState & 0x00FF)
{
case DEV_CTRLWAY_OPEN:
case DEV_CTRLWAY_CLOSE:
case CFG_Dev_CtrlWay_Is_TOGGLE:
case 0x05:
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
DevActionInfo->DevActionState.DevAddrIn,
DevActionInfo->DevActionInput.inAddr,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DEV_CTRLWAY_STOP);
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"485窗帘场景关闭控制 state:%4X",DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
break;
case DEV_CTRLWAY_STOP:
break;
}
break;
case SLEEP_MODE_CTRL: //睡眠模式 窗帘控制
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
break;
}
}
break;
case Dev_Host_Service: //睡眠控制服务信息
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
if(BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL)
{
switch(ModeCtrl)
{
case NOR_MODE_CTRL: //普通模式 服务信息控制
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState)
{
case DEV_CTRLWAY_OPEN:
case DEV_CTRLWAY_CLOSE:
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DEV_CTRLWAY_CLOSE);
break;
}
break;
case SLEEP_MODE_CTRL: //睡眠模式 服务信息控制
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevAddrOut,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState);
break;
}
}
break;
}
}else if( (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont != 0x00) && (DevActionInfo->DevActionOutput[i].DevDlyAddr != 0x00) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"准备延时设备执行置位，设备类型:%d %d路 内容: %d,时间：%d单位：%d",
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayWeight);
DevDly_InfoSet(DevActionInfo->DevActionOutput[i].DevDlyAddr,
0x00,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue,
0x00);
}
}
}
}
/*******************************************************************************
* Function Name : DevAction_Mode_Ctrl
* Description : 场景模式控制
* Input :
DevActionInfo : 动作场景信息
Mode ：0x01-场景控制，0x02-灯光控制
SceneMode ：NOR_MODE_CTRL 0x01 普通模式控制；SLEEP_MODE_CTRL 0x02 睡眠场景控制
CtrlState ：控制状态 1-开，2-关
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void DevAction_ExpandDlyClear(DEV_ACTION_INFO *DevActionInfo)
{
uint8_t i = 0;
uint32_t DevAddrOut = 0x00;
Device_Public_Information_G BUS_Public;
for(i = 0; i < DevActionInfo->DevCtrlNum; i++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutAddr != 0x00)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType != Dev_Host_Invalid)
{
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevAddrOut);
}
if( (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont != 0x00) && (DevActionInfo->DevActionOutput[i].DevDlyAddr != 0x00) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"准备延时设备执行置位，设备类型:%d %d路 内容: %d,时间：%d单位：%d",
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayWeight);
DevDly_InfoSet(DevActionInfo->DevActionOutput[i].DevDlyAddr,
0x00,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue,
0x00);
}
}
}
}
/*******************************************************************************
* Function Name : DevAction_No_Get
* Description : 根据场景编号得到动作的地址
* Input :
DevActionInfo : 动作场景信息
Mode ：0x01-场景控制，0x02-灯光控制
SceneMode ：NOR_MODE_CTRL 0x01 普通模式控制；SLEEP_MODE_CTRL 0x02 睡眠场景控制
CtrlState ：控制状态 1-开，2-关
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) uint32_t DevAction_No_Get(uint16_t DevActionNo)
{
uint16_t i = 0;
uint32_t list_addr = 0;
DEV_ACTION_INFO DevActionInfo;
for(i = 0; i < DevActionGlobal.DevActionNum; i++ )
{
list_addr = SRAM_DevAction_List_Start_Addr + i*SRAM_DevAction_List_Size;
SRAM_DMA_Read_Buff((uint8_t *)&DevActionInfo, sizeof(DEV_ACTION_INFO), list_addr);
if(DevActionInfo.DevActionCore.ActionNo == DevActionNo)
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"遍历所有动作，找到相应的场景编号:%d 场景名%s", DevActionNo, DevActionInfo.DevActionCore.DevActionName);
return list_addr; //返回当前动作的地址
}
}
return 0x00;
}
/*******************************************************************************
* Function Name : DevAction_Mode_Ctrl
* Description : 场景模式控制
* Input :
DevActionInfo : 动作场景信息
Mode ：0x01-场景控制，0x02-灯光控制
SceneMode ：NOR_MODE_CTRL 0x01 普通模式控制；SLEEP_MODE_CTRL 0x02 睡眠场景控制
CtrlState ：控制状态 1-开，2-关
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void DevAction_Mode_Ctrl(
DEV_ACTION_INFO *DevActionInfo,
uint8_t Mode,
uint8_t SceneMode,
uint16_t CtrlState)
{
switch(CtrlState)
{
case DEV_CTRLWAY_OPEN:
switch(Mode)
{
case SCENE_MODE_CTRL:
DevAction_ExpandCtrl(DevActionInfo);
break;
case LIGHT_MODE_CTRL:
DevAction_ExpandLightOpen(DevActionInfo);
break;
}
break;
case DEV_CTRLWAY_CLOSE:
switch(Mode)
{
case SCENE_MODE_CTRL:
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"普通场景控制关闭，场景号:%d", DevActionInfo->DevActionCore.ActionNo);
DevAction_ExpandClose(DevActionInfo, SceneMode);
break;
case LIGHT_MODE_CTRL:
DevAction_ExpandLightClose(DevActionInfo);
break;
}
break;
case DEV_CTRLWAY_INVALID: //控制方式无效，就是取消所有的延时执行
DevAction_ExpandDlyClear(DevActionInfo);
break;
}
}
/*******************************************************************************
* Function Name : DevAction_Output
* Description : 设备动作输出执行
* Input :
DevActionNo : 场景编号
Mode ：0x01-场景控制，0x02-灯光控制
CtrlState ：控制状态 1-开，2-关
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void DevAction_No_Ctrl(uint16_t DevActionNo, uint8_t Mode, uint16_t CtrlState)
{
uint16_t i = 0x00; //用于遍历所有动作
uint32_t list_addr = 0x00; //动作的地址
DEV_ACTION_INFO DevActionInfo;
Dev_Dly_Value Temp_Dly;
if(DevActionNo == 0x00) return ; //直接退出
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"遍历所有动作，准备执行场景编号:%d", DevActionNo);
for(i = 0; i < DevActionGlobal.DevActionNum; i++)
{
list_addr = SRAM_DevAction_List_Start_Addr + i*SRAM_DevAction_List_Size;
SRAM_DMA_Read_Buff((uint8_t *)&DevActionInfo, sizeof(DEV_ACTION_INFO), list_addr);
if(DevActionInfo.DevActionCore.ActionNo == DevActionNo)
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"找到相应的场景编号:%d 场景名%s，场景存储地址:%08X,立即执行，并清延时执行标志", \
DevActionNo, \
DevActionInfo.DevActionCore.DevActionName, \
list_addr);
Temp_Dly.DelayCont = 0x00;
Temp_Dly.DelayWeight = 0x00;
DevDly_InfoSet(DevDlyAddr_Get(list_addr, DevActionNo), 0x00, 0x00, Temp_Dly, 0x00);//置延时执行标志位 先拿到延时节点的地址
if( (DevActionNo == ACTION_SCENE_SLEEP) || (DevActionInfo.DevActionCond.SceneExcute == ACTION_SCENE_SLEEP) )
{
DevAction_Mode_Ctrl(&DevActionInfo, Mode, SLEEP_MODE_CTRL, CtrlState);
}else {
DevAction_Mode_Ctrl(&DevActionInfo, Mode, NOR_MODE_CTRL, CtrlState);
}
if( DevActionGlobal.ServerCtrl == 0x01 )
{
DevActionGlobal.ServerCtrl = 0x00;
if( DevActionInfo.DevActionCond.SceneExcute == ACTION_SCENE_SLEEP )
{
if( DevActionGlobal.DevActionU64Cond.NeightFlag == 0x01 ) //与夜灯有关，且夜灯存在
{
if( DevActionGlobal.DevActionU64Cond.NeightState != NightModeStart)
{
DevActionGlobal.DevActionU64Cond.NeightState = NightModeStart;
}
}
DevActionGlobal.SleepMode_State = 0x01; //睡眠模式开
DevActionGlobal.SleepLight_State = 0x00; //熄灭背光，关背光
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"进入睡眠场景");
}else {
if( DevActionGlobal.DevActionU64Cond.NeightFlag == 0x01 ) //与夜灯有关，且夜灯存在
{
DevActionGlobal.DevActionU64Cond.NeightState = NightModeClose;
}
DevActionGlobal.SleepMode_State = 0x00; //睡眠模式关
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"退出睡眠场景");
}
}
break;
}
}
}
/*******************************************************************************
* Function Name : DevAction_Output
* Description : 设备动作输出执行
* Input :
DevActionInfo : 设备动作信息结构体
* Return : None
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void DevAction_Output(DEV_ACTION_INFO *DevActionInfo)
{
switch( DevActionInfo->DevActionCond.SceneExcute )
{
case ACTION_SCENE_ONE:
case ACTION_SCENE_MULTI:
if( ( DevActionGlobal.DevActionU64Cond.NeightFlag == 0x01 )
&& ( 0x01 == DevActionInfo->DevActionCond.DevActionU64Cond.NeightFlag ) )
{
switch( DevActionGlobal.DevActionU64Cond.NeightState )
{
case NightModeStart:
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯有关 场景不可关闭 准备执行打开夜灯:");
DevActionGlobal.DevActionU64Cond.NeightState = NightModeOpen;
DevAction_No_Ctrl(DevActionGlobal.SleepActionNo, 0x02, DEV_CTRLWAY_OPEN); //打开夜灯
if( DevActionInfo->DevActionInput.DevType == DEV_RS485_SWT )
{
DevActionGlobal.SleepMode_State = 0x00;
Logic_Music_Ctrl(0x00, 0x00, Find_Device_List_Information(0x15,0x01), 0x00, 0x0020); //起夜关音乐
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"退出睡眠场景 -1");
}
break;
case NightModeOpen:
DevActionGlobal.DevActionU64Cond.NeightState = NightModeClose;
DevAction_No_Ctrl(DevActionGlobal.SleepActionNo, 0x02, DEV_CTRLWAY_CLOSE);//关闭夜灯
case NightModeClose:
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯有关 场景不可关闭开始对所有设备输出状态进行赋值:");
DevAction_ExpandCtrl(DevActionInfo); //执行当前场景
break;
}
}else {
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯无关 场景不可关闭开始对所有设备输出状态进行赋值:");
DevAction_ExpandCtrl(DevActionInfo);
if(DevActionInfo->DevActionInput.DevType == DEV_RS485_SWT)
{
DevActionGlobal.SleepMode_State = 0x00;
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"退出睡眠场景 -2");
}
}
break;
case ACTION_SCENE_TWO: //场景可关闭，执行相应动作
if( (DevActionGlobal.DevActionU64Cond.NeightFlag == 0x01) && (DevActionInfo->DevActionCond.DevActionU64Cond.NeightFlag == 0x01) )
{
switch(DevActionGlobal.DevActionU64Cond.NeightState)
{
case NightModeStart:
DevActionGlobal.DevActionU64Cond.NeightState = NightModeOpen;
DevAction_No_Ctrl(DevActionGlobal.SleepActionNo, 0x02, DEV_CTRLWAY_OPEN); //打开夜灯
if(DevActionInfo->DevActionInput.DevType == DEV_RS485_SWT)
{
DevActionGlobal.SleepMode_State = 0x00; //睡眠模式关 2025-09-05
Logic_Music_Ctrl(0x00, 0x00, Find_Device_List_Information(0x15,0x01), 0x00, 0x0020); //起夜关音乐
}
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"退出睡眠场景 -3");
break;
case NightModeClose:
case NightModeOpen:
if(NightModeOpen == DevActionGlobal.DevActionU64Cond.NeightState)
{
DevActionGlobal.DevActionU64Cond.NeightState = NightModeClose;
DevAction_No_Ctrl(DevActionGlobal.SleepActionNo, 0x02, DEV_CTRLWAY_CLOSE); //关闭夜灯
}
if(DEV_STATE_CLOSE == DevActionInfo->DevActionState.SceneState) //当前场景为关
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯有关 场景可关闭开始对所有设备输出状态进行赋值:准备执行场景开");
DevAction_ExpandCtrl(DevActionInfo); //执行当前场景
}
else if(DEV_STATE_OPEN == DevActionInfo->DevActionState.SceneState)
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯有关 场景可关闭开始对所有设备输出状态进行赋值:准备执行场景关");
DevAction_ExpandClose(DevActionInfo, NOR_MODE_CTRL); //执行当前场景
}
break;
}
}else {
if(DEV_STATE_CLOSE == DevActionInfo->DevActionState.SceneState) //当前场景为关
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯无关 场景可关闭开始对所有设备输出状态进行赋值:准备执行场景开");
DevAction_ExpandCtrl(DevActionInfo); //执行当前场景
}
else if(DEV_STATE_OPEN == DevActionInfo->DevActionState.SceneState) //当前场景为开
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯无关 场景可关闭开始对所有设备输出状态进行赋值:准备执行场景关");
DevAction_ExpandClose(DevActionInfo, NOR_MODE_CTRL); //执行当前场景
}
if(DevActionInfo->DevActionInput.DevType == DEV_RS485_SWT)
{
DevActionGlobal.SleepMode_State = 0x00; //睡眠模式关
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"退出睡眠场景 -4");
}
}
break;
case ACTION_SCENE_MAINSWITCH: //总开关
if( (DevActionGlobal.DevActionU64Cond.NeightFlag == 0x01) && (DevActionInfo->DevActionCond.DevActionU64Cond.NeightFlag == 0x01) )
{
switch(DevActionGlobal.DevActionU64Cond.NeightState)
{
case NightModeStart:
DevActionGlobal.DevActionU64Cond.NeightState = NightModeOpen;
DevAction_No_Ctrl(DevActionGlobal.SleepActionNo, 0x02, DEV_CTRLWAY_OPEN); //打开夜灯
if(DevActionInfo->DevActionInput.DevType == DEV_RS485_SWT)
{
DevActionGlobal.SleepMode_State = 0x00; //睡眠模式关
Logic_Music_Ctrl(0x00, 0x00, Find_Device_List_Information(0x15,0x01), 0x00, 0x0020); //起夜关音乐
}
break;
case NightModeClose:
case NightModeOpen:
if(DevActionGlobal.DevActionU64Cond.NeightState == NightModeOpen)
{
DevActionGlobal.DevActionU64Cond.NeightState = NightModeClose;
DevAction_No_Ctrl(DevActionGlobal.SleepActionNo, 0x02, DEV_CTRLWAY_CLOSE); //关闭夜灯
}
if(DevActionInfo->DevActionState.SceneState == DEV_STATE_CLOSE) //当前场景为关
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯有关 场景可关闭开始对所有设备输出状态进行赋值:准备执行场景开");
DevAction_ExpandLightOpen(DevActionInfo); //打开当前场景的灯光
}
else if(DevActionInfo->DevActionState.SceneState == DEV_STATE_OPEN)
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯有关 场景可关闭开始对所有设备输出状态进行赋值:准备执行场景关");
DevAction_ExpandClose(DevActionInfo, SLEEP_MODE_CTRL); //执行当前场景，灯光类设备关闭
}
break;
}
}else {
if(DevActionInfo->DevActionState.SceneState == DEV_STATE_CLOSE) //当前场景为关
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯无关 场景可关闭开始对所有设备输出状态进行赋值:准备执行场景开");
DevAction_ExpandLightOpen(DevActionInfo); //打开当前场景的灯光
}
else if(DevActionInfo->DevActionState.SceneState == DEV_STATE_OPEN) //当前场景为开
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯无关 场景可关闭开始对所有设备输出状态进行赋值:准备执行场景关");
DevAction_ExpandClose(DevActionInfo, SLEEP_MODE_CTRL); //执行当前场景
}
if(DevActionInfo->DevActionInput.DevType == DEV_RS485_SWT)
{
DevActionGlobal.SleepMode_State = 0x00; //睡眠模式关
}
}
break;
case ACTION_SCENE_SLEEP: //睡眠模式 ，全部关才算开，有一个开就算关。
if(DevActionGlobal.DevActionU64Cond.NeightFlag == 0x01) //与夜灯有关 且夜灯存在
{
if(DevActionGlobal.DevActionU64Cond.NeightState != NightModeStart)
{
DevActionGlobal.DevActionU64Cond.NeightState = NightModeStart; //进入起夜
DevAction_ExpandClose(DevActionInfo, SLEEP_MODE_CTRL); //睡眠场景为开 但是得关闭所有灯 并播放相应词条
DevActionGlobal.SleepMode_State = 0x01; //睡眠模式开
DevActionGlobal.SleepLight_State = 0x00; //熄灭
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"进入睡眠场景 1");
}else{
DevActionGlobal.DevActionU64Cond.NeightState = NightModeOpen;
DevAction_ExpandLightOpen(DevActionInfo); //打开夜灯
DevActionGlobal.SleepMode_State = 0x00; //睡眠模式关
Logic_Music_Ctrl(0x00, 0x00, Find_Device_List_Information(0x15,0x01), 0x00, 0x0020); //起夜关音乐
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"退出睡眠场景 1");
}
}else{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯无关 睡眠场景开始对所有设备输出状态进行赋值:");
DevAction_ExpandCtrl(DevActionInfo); //执行当前场景
DevActionGlobal.SleepMode_State = 0x01; //睡眠模式关
DevActionGlobal.SleepLight_State = 0x00; //熄灭
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"进入睡眠场景 2");
}
break;
case ACTION_SCENE_HELPSLEEP: //助眠模式 按下打开夜灯开启标志。此时按下普通按键，就能关闭夜灯，并取消睡眠倒计时
if((DevActionGlobal.DevActionU64Cond.NeightFlag == 0x01 )&& (DevActionInfo->DevActionCond.DevActionU64Cond.NeightFlag == 0x01)) //与夜灯有关 且夜灯存在
{
switch(DevActionGlobal.DevActionU64Cond.NeightState)
{
case NightModeStart:
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯有关 场景助眠 准备执行打开夜灯:");
DevActionGlobal.DevActionU64Cond.NeightState = NightModeOpen;
DevAction_No_Ctrl(DevActionGlobal.SleepActionNo, 0x02, DEV_CTRLWAY_OPEN);//打开夜灯 并取消睡眠倒计时
if(DevActionInfo->DevActionInput.DevType == DEV_RS485_SWT)
{
DevActionGlobal.SleepMode_State = 0x00; //睡眠模式关
}
Logic_Music_Ctrl(0x00, 0x00, Find_Device_List_Information(0x15,0x01), 0x00, 0x0020); //起夜关音乐
break;
case NightModeClose:
case NightModeOpen:
if(DevActionGlobal.DevActionU64Cond.NeightState == NightModeOpen) //夜灯标志开启
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯有关 场景助眠将夜灯标志关闭");
DevActionGlobal.DevActionU64Cond.NeightState = NightModeClose;
DevAction_No_Ctrl(DevActionGlobal.SleepActionNo, 0x02, DEV_CTRLWAY_CLOSE);//关闭夜灯
}
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯有关 场景助眠开始对所有设备输出状态进行赋值:");
DevAction_ExpandCtrl(DevActionInfo); //执行当前场景
if(DevActionInfo->DevActionInput.DevType == DEV_RS485_SWT)
{
DevActionGlobal.DevActionU64Cond.NeightState = NightModeStart; //进入起夜
DevActionGlobal.SleepMode_State = 0x01; //睡眠模式开
DevActionGlobal.SleepLight_State = 0x00; //熄灭
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"进入睡眠场景 3");
}
break;
}
}else{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯无关 助眠场景开始对所有设备输出状态进行赋值:");
DevAction_ExpandCtrl(DevActionInfo); //执行当前场景
if(DevActionInfo->DevActionInput.DevType == DEV_RS485_SWT)
{
DevActionGlobal.SleepMode_State = 0x01; //睡眠模式开
DevActionGlobal.SleepLight_State = 0x00; //熄灭
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"进入睡眠场景 4");
}
}
break;
#if RS485_Switch_Rotary_Flag
case ACTION_SCENE_Rotary: //旋转场景
if((DevActionGlobal.DevActionU64Cond.NeightFlag == 0x01) && (DevActionInfo->DevActionCond.DevActionU64Cond.NeightFlag == 0x01)) //与夜灯有关
{
switch(DevActionGlobal.DevActionU64Cond.NeightState)
{
case NightModeStart:
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯有关 旋钮场景 准备执行打开夜灯:");
DevActionGlobal.DevActionU64Cond.NeightState = NightModeOpen;
DevAction_No_Ctrl(DevActionGlobal.SleepActionNo, 0x02, DEV_CTRLWAY_OPEN);//打开夜灯
if(DevActionInfo->DevActionInput.DevType == DEV_RS485_SWT)
{
DevActionGlobal.SleepMode_State = 0x00; //睡眠模式关 2025-09-05
}
break;
case NightModeClose:
case NightModeOpen:
if(NightModeOpen == DevActionGlobal.DevActionU64Cond.NeightState)
{
DevActionGlobal.DevActionU64Cond.NeightState = NightModeClose;
DevAction_No_Ctrl(DevActionGlobal.SleepActionNo, 0x02, DEV_CTRLWAY_CLOSE);//关闭夜灯
}
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯有关 旋钮场景 开始对所有设备输出状态进行赋值:");
DevAction_RotaryCtrl(DevActionInfo);
break;
}
}else{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯无关 旋钮场景开始对所有设备输出状态进行赋值:");
DevAction_RotaryCtrl(DevActionInfo);
}
break;
#endif
case ACTION_SCENE_SLEEP_UNRELATED:
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"与夜灯无关 无卡取电-任意按键 准备执行打开夜灯:");
DevAction_ExpandCtrl(DevActionInfo); //执行当前场景
break;
}
if(DevActionGlobal.DevActionU64Cond.NeightState != DevActionGlobal.Last_NeightState) {
DevActionGlobal.Last_NeightState = DevActionGlobal.DevActionU64Cond.NeightState;
}
}
/*******************************************************************************
* @Function Name : DevAction_IndicateCtrl
* @Description : 设备动作反馈灯输出执行
* @Input :
* DevActionInfo : 设备动作信息
* @Return ：无
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void DevAction_IndicateCtrl(DEV_ACTION_INFO *DevActionInfo)
{
uint8_t i = 0x00;
uint8_t CtrlWay = 0x00;
Device_Public_Information_G BUS_Public;
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"场景状态改变准备执行反馈灯控制：场景名:%s，控制状态：%d,设备数量:%d",
DevActionInfo->DevActionCore.DevActionName,
DevActionInfo->DevActionState.SceneState,
DevActionInfo->DevCtrlNum);
for(i = 0; i < DevActionInfo->DevCtrlNum; i++)
{
if(DevActionInfo->DevActionOutput[i].DevActionOutAddr != 0x00)
{
switch(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevType)
{
case DEV_RS485_SWT:
case Dev_Host_LVoutput:
CtrlWay = DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState&0x00ff;
switch(CtrlWay)
{
case DEV_CTRLWAY_RELATESCENE:
switch(DevActionInfo->DevActionState.SceneState)
{
case DEV_STATE_OPEN:
case DEV_STATE_CLOSE:
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevActionInfo->DevActionOutput[i].DevActionOutAddr);
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"反馈灯控制顺便清延时执行,设备类型: %d 地址:%d，回路:%d，状态:%d",
BUS_Public.type,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionState.SceneState);
DevDly_InfoSet(
DevActionInfo->DevActionOutput[i].DevDlyAddr,
0x00,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue,
0x00); //关闪烁 关延时
if(NULL != BUS_Public.DevFunInfo.Dev_Output_Ctrl)
{
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevActionInfo->DevActionOutput[i].DevActionOutAddr,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionState.SceneState); //根据场景状态去控制反馈灯
}
break;
}
break;
case CFG_Dev_CtrlWay_Is_RelateBlink:
if(0x00 != DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue.DelayCont) //立即执行
{
switch(DevActionInfo->DevActionState.SceneState)
{
case DEV_STATE_OPEN: //开启闪烁 应先开指示灯
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevActionInfo->DevActionOutput[i].DevActionOutAddr);
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"开启闪烁,状态:%04X",CFG_Dev_CtrlWay_Is_TOGGLE |(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState&0xff00));
DevDly_InfoSet(
DevActionInfo->DevActionOutput[i].DevDlyAddr,
0x01,
CFG_Dev_CtrlWay_Is_TOGGLE |(DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState&0xff00),
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue,
0x01);
if(BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL)
{
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevActionInfo->DevActionOutput[i].DevActionOutAddr,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DEV_CTRLWAY_OPEN | ( DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState & 0xff00 ) );
}
break;
case DEV_STATE_CLOSE: //关闭闪烁 应后关指示灯
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"关闭闪烁");
DevDly_InfoSet(
DevActionInfo->DevActionOutput[i].DevDlyAddr,
0x01,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevDlyValue,
0x02);
break;
}
}
break;
}
break;
case Dev_NodeCurtain:
if( (DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevCtrlState & 0x00ff) == DEV_CTRLWAY_RELATESCENE )
{
if( DevActionInfo->DevActionState.SceneState == DEV_STATE_OPEN )
{
switch(DevActionInfo->DevActionInput.inType)
{
case DEV_CTRLWAY_OPEN: //开
case DEV_CTRLWAY_CLOSE: //关
case DEV_CTRLWAY_STOP: //停
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public,sizeof(Device_Public_Information_G),DevActionInfo->DevActionOutput[i].DevActionOutAddr);
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"反馈灯控制顺便清延时执行,设备类型: %d 地址:%d，回路:%d，状态:%d",
BUS_Public.type,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevAddr,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionState.SceneState);
if(BUS_Public.DevFunInfo.Dev_Output_Ctrl != NULL)
{
BUS_Public.DevFunInfo.Dev_Output_Ctrl(
0x00,
0x00,
DevActionInfo->DevActionOutput[i].DevActionOutAddr,
DevActionInfo->DevActionOutput[i].DevActionOutCfg.DevOutputLoop,
DevActionInfo->DevActionInput.inType);
}
break;
}
}
}
break;
}
}
}
}
/*******************************************************************************
* @Function Name : BLV_DevAction_Cycle
* @Description : 遍历所有的动作，相同输入触发节点的动作一起扫描
* @Input :
* Dev_processing_addr : 设备动作地址
* BUS_Public ：公共属性
* @Return ：无
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void BLV_DevAction_Cycle(uint32_t Dev_processing_addr,Device_Public_Information_G *BUS_Public)
{
DEV_ACTION_INFO DevActionInfo; //设备动作全部信息 - 占用512Byte
uint32_t DevActionAddr = 0x00,temp_offset = 0x00; //用于遍历所有动作存在
uint16_t j = 0x00; //用于遍历动作存在
uint8_t BreakFlag = 0x00; //跳出循环标志 有设备控制执行
for(j = BUS_Public->ActionCoord; j < DevActionGlobal.DevActionNum; j++) //这里为啥需要这个循环？？？？ - 疑问点
{
DevActionAddr = SRAM_DevAction_List_Start_Addr + j*SRAM_DevAction_List_Size;
temp_offset = DevActionAddr + sizeof(Dev_Action_Core) + sizeof(Dev_Action_Input) + sizeof(Dev_Action_Cond) + sizeof(Dev_Action_State) - 4;
if(SRAM_Read_DW(temp_offset) == Dev_processing_addr) //拥有相同的输入触发节点 DevActionInfo.DevActionState.DevAddrIn
{
SRAM_DMA_Read_Buff((uint8_t *)&DevActionInfo, sizeof(DEV_ACTION_INFO), DevActionAddr); //完整拷贝设备动作信息 根据设备输出数量去执行控制
if( Data_CheckSum((uint8_t *)&DevActionInfo, sizeof(DEV_ACTION_INFO)) != 0x00 )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"动作参数校验未通过:%d");
continue;
}
RcuLockState_Scan();
DevAction_State_Get(&DevActionInfo); //当前场景状态更新 结合所有设备输出去判断
if( DevActionInfo.DevActionCond.DevActionU64Cond.DevActionOutFlag == 0x00 ) //设备动作 - 条件中动作启用标志位
{
if( DevActionInfo.DevActionState.SceneReuseFlag == 0x00 ) //场景状态 - 复用标志位不成立 疑问点：复用标志位的作用是什么？？？
{
if( (BUS_Public->DevFunInfo.Dev_Input_Type_Get != NULL)
&& (BUS_Public->DevFunInfo.Dev_Input_Type_Get(DevActionInfo.DevActionState.DevAddrIn, DevActionInfo.DevActionInput.inAddr, DevActionInfo.DevActionInput.inType) == CtrlValid) )
{
if(BLV_DevAction_Cond_Judge(&DevActionInfo) == CondIsPass)
{
BreakFlag = 0x01;
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"设备类型:%d 设备地址%d 输入地址:%d 地址编号:%d 动作地址:%08X通过", \
DevActionInfo.DevActionInput.DevType, \
DevActionInfo.DevActionInput.DevAddr, \
DevActionInfo.DevActionInput.inAddr, \
DevActionInfo.DevActionCore.ActionNo, \
DevActionAddr);
DevAction_Output(&DevActionInfo); //执行输出控制
}else if(DevActionInfo.DevActionCond.DevActionU64Cond.EleCtrlFlag == 0x01)
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"设备类型:%d 设备地址%d 输入地址:%d 地址编号:%d 动作地址:%08X未通过，但是有控取电开标志",
DevActionInfo.DevActionInput.DevType,
DevActionInfo.DevActionInput.DevAddr,
DevActionInfo.DevActionInput.inAddr,
DevActionInfo.DevActionCore.ActionNo,
DevActionAddr);
if(0x00 == Get_Authorize_Lock_Status()) //授权锁定判断
{
BreakFlag = 0x01;
Ele_Ctrl_OpenClose(0x01); //控制取电服务打开
}
}
}
}else if(DevActionInfo.DevActionState.SceneReuseFlag == 0x01) //存在复用标志
{
if( (DevActionInfo.DevActionCond.SceneExcute == ACTION_SCENE_MULTI) && (DevActionInfo.DevActionInput.DevType == DEV_RS485_SWT) )
{
if( (CondIsPass == BLV_DevAction_Cond_Judge(&DevActionInfo)) && (BUS_Public->DevFunInfo.Dev_Input_Type_Get != NULL) )
{
uint8_t ret = BUS_Public->DevFunInfo.Dev_Input_Type_Get(DevActionInfo.DevActionState.DevAddrIn, DevActionInfo.DevActionInput.inAddr, DevActionInfo.DevActionInput.inType);
if( (ret & 0x01) == CtrlValid )
{
if( DevActionInfo.DevActionState.MultiNumber == (ret >> 0x01) )
{
BreakFlag = 0x01;
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"多联场景别名:%s,设备类型复用:%d 设备地址%d 输入地址:%d 动作编号:%d 动作地址:%08X通过",
DevActionInfo.DevActionCore.DevActionName,
DevActionInfo.DevActionInput.DevType,
DevActionInfo.DevActionInput.DevAddr,
DevActionInfo.DevActionInput.inAddr,
DevActionInfo.DevActionCore.ActionNo,
DevActionAddr);
DevAction_Output(&DevActionInfo); //执行输出控制
}else {
//当前动作多联下标和开关触发多联下标不相等，重新寻找动作地址
uint32_t TempAddr = 0x00,deal_addr = 0;
deal_addr = TempAddr+sizeof(Dev_Action_Core)+sizeof(Dev_Action_Input)+sizeof(Dev_Action_Cond)+sizeof(Dev_Action_State) - 4 ;
for(uint8_t i = 0; i < DevActionGlobal.DevActionNum; i++ )
{
TempAddr = SRAM_DevAction_List_Start_Addr + i * SRAM_DevAction_List_Size;
if( SRAM_Read_DW(deal_addr) == Dev_processing_addr )
{
deal_addr = deal_addr - 3;
if( SRAM_Read_Byte(deal_addr) == (ret >> 0x01) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"找到多联编号:%d 动作地址:%08X",SRAM_Read_Byte(deal_addr),TempAddr);
break;
}
}
}
deal_addr = TempAddr+sizeof(Dev_Action_Core)+sizeof(Dev_Action_Input)+sizeof(Dev_Action_Cond)+sizeof(Dev_Action_State) - 4 ;
if( (TempAddr != 0x00) && (SRAM_Read_DW(deal_addr) == Dev_processing_addr) )
{
SRAM_DMA_Read_Buff((uint8_t *)&DevActionInfo, sizeof(DEV_ACTION_INFO), TempAddr);
if( Data_CheckSum( (uint8_t *)&DevActionInfo, sizeof(DEV_ACTION_INFO) ) != 0x00 )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"动作参数校验未通过:%d");
continue ;
}
BreakFlag = 0x01;
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"多联场景别名:%s,设备类型复用:%d 设备地址%d 输入地址:%d 动作编号:%d 动作地址:%08X通过",
DevActionInfo.DevActionCore.DevActionName,
DevActionInfo.DevActionInput.DevType,
DevActionInfo.DevActionInput.DevAddr,
DevActionInfo.DevActionInput.inAddr,
DevActionInfo.DevActionCore.ActionNo,
DevActionAddr);
DevAction_Output(&DevActionInfo); //执行输出控制
}
}
}
}
}else {
if( (BLV_DevAction_Cond_Judge(&DevActionInfo) == CondIsPass)
&& (BUS_Public->DevFunInfo.Dev_Input_Type_Get != NULL)
&& ( BUS_Public->DevFunInfo.Dev_Input_Type_Get(
DevActionInfo.DevActionState.DevAddrIn,
DevActionInfo.DevActionInput.inAddr,
DevActionInfo.DevActionInput.inType ) == CtrlValid ) )
{
BreakFlag = 0x01;
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"场景别名:%s,设备类型复用:%d 设备地址%d 输入地址:%d 动作编号:%d 动作地址:%08X通过",
DevActionInfo.DevActionCore.DevActionName,
DevActionInfo.DevActionInput.DevType,
DevActionInfo.DevActionInput.DevAddr,
DevActionInfo.DevActionInput.inAddr,
DevActionInfo.DevActionCore.ActionNo,
DevActionAddr);
DevAction_Output(&DevActionInfo); //执行输出控制
}
}
}
}
if(BreakFlag == 0x01) //本地产生事件，就立即刷新场景状态
{
DevAction_State_Get(&DevActionInfo); //当前场景状态更新 结合所有设备输出去判断
}
//场景状态改变,控制反馈灯
if( DevActionInfo.DevActionState.SceneState != DevActionInfo.DevActionState.SceneStateLast )
{
DevActionInfo.DevActionState.SceneStateLast = DevActionInfo.DevActionState.SceneState;
DevAction_IndicateCtrl(&DevActionInfo);
DevActionInfo.CheckVal = 0x00;
DevActionInfo.CheckVal = Data_CheckSum((uint8_t *)&DevActionInfo, sizeof(DEV_ACTION_INFO));
SRAM_DMA_Write_Buff((uint8_t *)&DevActionInfo, sizeof(DEV_ACTION_INFO), DevActionAddr);
}
if(BreakFlag == 0x01)
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"当前动作下标:%d", j);
break;
}
}
}
}
/*******************************************************************************
* @Function Name : BLV_DevAction_Task
* @Description : BLV设备动作任务处理函数
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void BLV_DevAction_Task(void)
{
static uint32_t dev_action_processing_tick = 0;
uint32_t Dev_processing_addr;
Device_Public_Information_G BUS_Public; //公有全局数据
uint8_t BreakFlag = 0x00;
if( SysTick_1ms - dev_action_processing_tick >= 50)
{
if(DevActionGlobal.Devi >= DevActionGlobal.DevNum)
{
DevActionGlobal.Devi = 0x00;
}
for( ; DevActionGlobal.Devi < DevActionGlobal.DevNum ;)
{
Dev_processing_addr = SRAM_Device_List_Start_Addr + DevActionGlobal.Devi*SRAM_Device_List_Size;
switch(SRAM_Read_Byte(Dev_processing_addr+Dev_Type))
{
case Dev_Host_LVinput: //虚拟设备 - 弱电输入
case Dev_NodeCurtain: //干接点设备 - 窗帘
case DEV_RS485_CARD: //RS485设备 - 插卡取电
case DEV_RS485_TEMP: //RS485设备 - 温控器
case Dev_Host_Service: //虚拟设备 - 服务信息
case DEV_RS485_SWT: //RS485设备 - 开关
case DEV_RS485_PWM: //RS485设备 - 调光
case DEV_RS485_FreshAir: //RS485设备 - 新风
case DEV_RS485_HEATER: //RS485设备 - 地暖
case Dev_Rs458_RotaryCtrl: //RS485设备 - 旋钮开关
case DEV_Virtual_Card: //虚拟设备 - 无卡取电
case DEV_Carbon_Saved: //虚拟设备 - 碳达人
case Dev_Scene_Restore: //虚拟设备 - 场景还原
BreakFlag = 0x01;
SRAM_DMA_Read_Buff((uint8_t *)&BUS_Public, sizeof(Device_Public_Information_G), Dev_processing_addr); //拷贝所有公有数据
BLV_DevAction_Cycle(Dev_processing_addr, &BUS_Public); //找到输入节点，把地址和全局属性传进去
break;
}
DevActionGlobal.Devi++;
if(BreakFlag == 0x01) break;
}
dev_action_processing_tick = SysTick_1ms;
}
}
/*******************************************************************************
* @Function Name : BLV_DevAction_Cycle
* @Description : 遍历所有的动作，相同输入触发节点的动作一起扫描
* @Input :
* Dev_processing_addr : 设备动作地址
* BUS_Public ：公共属性
* @Return ：无
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void DevAction_DevAddr_Ctrl(
uint32_t DevActionAddr,
uint8_t Mode,
uint8_t SceneMode,
uint16_t CtrlState)
{
DEV_ACTION_INFO DevActionInfo;
if( (DevActionAddr < SRAM_DevAction_List_Start_Addr) || (DevActionAddr >= SRAM_DevAction_List_End_Addr) )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"场景地址无效:%08X",DevActionAddr);
return ;
}
SRAM_DMA_Read_Buff((uint8_t *)&DevActionInfo, sizeof(DEV_ACTION_INFO), DevActionAddr);
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"场景控制，场景地址有效:%08X，场景号:%d",DevActionAddr, DevActionInfo.DevActionCore.ActionNo);
if( DevActionInfo.DevActionCore.ActionNo == ACTION_SCENE_SLEEP )
{
if( DevActionGlobal.DevActionU64Cond.NeightFlag == 0x01 )
{
if( DevActionGlobal.DevActionU64Cond.NeightState != NightModeStart )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"设备输出场景控制，有场景控制睡眠，进入起夜");
DevActionGlobal.DevActionU64Cond.NeightState = NightModeStart;
}
}
DevAction_Mode_Ctrl(&DevActionInfo, LIGHT_MODE_CTRL, SLEEP_MODE_CTRL, DEV_CTRLWAY_CLOSE);
}else {
DevAction_Mode_Ctrl(&DevActionInfo, Mode, SceneMode, CtrlState);
}
}
/*******************************************************************************
* @Function Name : BLV_DevDly_Process
* @Description : 延时设备处理函数
* 延时设备执行有两种:
* 设备控制
* 挂起动作继续执行
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void BLV_DevDly_Process(uint32_t dly_processing_addr)
{
Struct_Dev_Dly DevDlyInfo;
uint8_t KeepFlag = 0x00;
Dev_Output_Ctrl_ptr Dev_Output_Ctrl;
SRAM_DMA_Read_Buff((uint8_t *)&DevDlyInfo, sizeof(Struct_Dev_Dly), dly_processing_addr);
if( (DevDlyInfo.DlyExcuteFlag == 0x01) && (SysTick_1ms >= DevDlyInfo.DlyExcuteTime) )
{
DevDlyInfo.DlyExcuteFlag = 0x00; //标志清0
KeepFlag = 0x01;
if(DevDlyInfo.DevDlyCore.DevDlyAddr != 0x00)
{
switch(DevDlyInfo.DevDlyCore.DevType)
{
case Dev_Host_HVout:
case Dev_Host_LVoutput:
case Dev_Host_Service:
case Dev_NodeCurtain:
case DEV_RS485_TEMP:
case DEV_RS485_SWT:
case DEV_RS485_STRIP:
case DEV_RS485_PWM:
case DEV_RS485_MUSIC:
case DEV_RS485_CURTAIN:
case DEV_RS485_FreshAir:
case DEV_RS485_HEATER:
case Dev_Rs485_PB20:
case Dev_Rs485_PB20_LD:
case Dev_Rs485_PB20_LS:
case Dev_Rs485_PB20_Relay:
case DEV_Virtual_NoCard:
case DEV_Virtual_Card:
case DEV_Virtual_ColorTemp:
case Dev_485_BLE_Music:
case DEV_Carbon_Saved:
case Dev_Energy_Monitor:
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"延时设备执行类型:%d %d路 内容: %04X",DevDlyInfo.DevDlyCore.DevType, DevDlyInfo.DevDlyCore.DevOutputLoop ,DevDlyInfo.DevOutputType);
Dev_Output_Ctrl = (Dev_Output_Ctrl_ptr)SRAM_Read_DW(DevDlyInfo.DevDlyCore.DevDlyAddr + Dev_Output_Ctrl_0);
if(Dev_Output_Ctrl != NULL)
{
Dev_Output_Ctrl(0x00, 0x00, DevDlyInfo.DevDlyCore.DevDlyAddr, DevDlyInfo.DevDlyCore.DevOutputLoop, DevDlyInfo.DevOutputType);
}
break;
case Dev_Host_Invalid:
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"场景延时执行到时间，场景地址:%08X 状态: %04X",DevDlyInfo.DevDlyCore.DevDlyAddr, DevDlyInfo.DevOutputType);
DevAction_DevAddr_Ctrl(DevDlyInfo.DevDlyCore.DevDlyAddr, 0x01, NOR_MODE_CTRL, DevDlyInfo.DevOutputType);
break;
}
}
if( KeepFlag == 0x01 )
{
SRAM_DMA_Write_Buff((uint8_t *)&DevDlyInfo,sizeof(Struct_Dev_Dly),dly_processing_addr);
}
if( DevDlyInfo.DlyBlinkFlag == 0x01 )
{
Dbg_Println(DBG_BIT_LOGIC_STATUS_bit,"当前延时链表存在延时闪烁执行类型:%d %d路 内容: %04X",DevDlyInfo.DevDlyCore.DevType, DevDlyInfo.DevDlyCore.DevOutputLoop ,DevDlyInfo.DevOutputType); //继电器状态赋值
DevDly_InfoSet(dly_processing_addr, 0x01, DevDlyInfo.DevOutputType, DevDlyInfo.DlyBlinkTime, 0x01);
}else if( DevDlyInfo.DlyBlinkFlag == 0x02 )
{
DevDly_InfoSet(dly_processing_addr, 0x01, DEV_CTRLWAY_CLOSE, DevDlyInfo.DlyBlinkTime, 0x00);
}
}
}
/*******************************************************************************
* @Function Name : BLV_DevDly_Task
* @Description : BLV设备动作任务处理函数
*******************************************************************************/
__attribute__((section(".non_0_wait"))) void BLV_DevDly_Task(void)
{
static uint32_t dev_devdly_processing_tick = 0;
uint32_t dly_processing_addr = 0;
if( SysTick_1ms - dev_devdly_processing_tick >= 10 )
{
dev_devdly_processing_tick = SysTick_1ms;
if( DevActionGlobal.DevDlyi > DevActionGlobal.DevDlyNum ) DevActionGlobal.DevDlyi = 0x00;
dly_processing_addr = SRAM_DevDly_List_Start_Addr + DevActionGlobal.DevDlyi*DevDlyStructLen;
BLV_DevDly_Process(dly_processing_addr);
DevActionGlobal.DevDlyi++;
}
}
Reference in New Issue View Git Blame Copy Permalink