结构体位域保存传感器数据

最新推荐文章于 2025-10-25 21:15:52 发布

原创最新推荐文章于 2025-10-25 21:15:52 发布 · 479 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#单片机

C 专栏收录该内容

9 篇文章

订阅专栏

文章介绍了如何使用8个74HC4052芯片共享两个选通引脚来检测64个数字红外传感器，通过位域结构体高效存储和处理状态，以及中间层和应用层的协作实现传感器状态的周期性更新。

1、原理图分析：

8个74HC4052共用两个选通引脚，8个输入引脚，一共可以检测64个数字红外传感器。74HC4052的功能表如下,nY0表示所有Y0引脚。

S1	S0	Channel on
0	0	nY0
0	1	nY1
1	0	nY2
1	1	nY3

enum sensor_id{
    HS01 = 0,		
    HS02,			
    HS03,			
    HS04,			
    HS05,			
    HS06,			
    HS07,			
    HS08,			
    HS09,			
    HS10,			
    HS11,			
    HS12,			
    HS13,			
    HS14,			
    HS15,			
    HS16,			
    HS17,
    HS18,
    HS19,
    HS20,
    HS21,
    HS22,
    HS23,
    HS24,
    HS25,
    HS26,
    HS27,
    HS28,
    HS29,
    HS30,
    HS31,
    HS32,
    HS33,
    HS34,
    HS35,
    HS36,
    HS37,
    HS38,
    HS39,
    HS40,
    HS41,
    HS42,
    HS43,
    HS44,
    HS45,
    HS46,
    HS47,
    HS48,
    HS49,
    HS50,
    HS51,
    HS52,
    HS53,
    HS54,
    HS55,
    HS56,
    HS57,
    HS58,
    HS59,
    HS60,
    HS61,
    HS62,
    HS63,
    HS64,
    HS_NUM    
};

#define RENEM_STEPS	4
uint8_t renew_flag = 0;
static uint8_t phase = 0;
volatile uint8_t g_u8sensorStatus[HS_NUM];
//周期性更新红外数字传感器的状态，200us调用一次	
void renew_irsensor_status(void)
{
	renew_flag = 1;
	if(++phase >= RENEM_STEPS)
		phase = 0;
	switch(phase)
	{
		case 0:
			//读取S1=0,S0=1
            g_u8sensorStatus[HS06] = GPIO_PinRead(BOARD_INITPINS_IRIN1_PORT,BOARD_INITPINS_IRIN1_PIN);
            g_u8sensorStatus[HS41] = GPIO_PinRead(BOARD_INITPINS_IRIN2_PORT,BOARD_INITPINS_IRIN2_PIN);
            g_u8sensorStatus[HS12] = GPIO_PinRead(BOARD_INITPINS_IRIN3_PORT,BOARD_INITPINS_IRIN3_PIN);
            g_u8sensorStatus[HS56] = GPIO_PinRead(BOARD_INITPINS_IRIN4_PORT,BOARD_INITPINS_IRIN4_PIN);
            g_u8sensorStatus[HS19] = GPIO_PinRead(BOARD_INITPINS_IRIN5_PORT,BOARD_INITPINS_IRIN5_PIN);
            g_u8sensorStatus[HS23] = GPIO_PinRead(BOARD_INITPINS_IRIN6_PORT,BOARD_INITPINS_IRIN6_PIN);
            g_u8sensorStatus[HS27] = GPIO_PinRead(BOARD_INITPINS_IRIN7_PORT,BOARD_INITPINS_IRIN7_PIN);
            g_u8sensorStatus[HS31] = GPIO_PinRead(BOARD_INITPINS_IRIN8_PORT,BOARD_INITPINS_IRIN8_PIN);
            g_u8sensorStatus[HS03] = GPIO_PinRead(BOARD_INITPINS_IRIN9_PORT,BOARD_INITPINS_IRIN9_PIN);
            g_u8sensorStatus[HS36] = GPIO_PinRead(BOARD_INITPINS_IRIN10_PORT,BOARD_INITPINS_IRIN10_PIN);
            g_u8sensorStatus[HS09] = GPIO_PinRead(BOARD_INITPINS_IRIN11_PORT,BOARD_INITPINS_IRIN11_PIN);
            g_u8sensorStatus[HS46] = GPIO_PinRead(BOARD_INITPINS_IRIN12_PORT,BOARD_INITPINS_IRIN12_PIN);
            g_u8sensorStatus[HS50] = GPIO_PinRead(BOARD_INITPINS_IRIN13_PORT,BOARD_INITPINS_IRIN13_PIN);
            g_u8sensorStatus[HS54] = GPIO_PinRead(BOARD_INITPINS_IRIN14_PORT,BOARD_INITPINS_IRIN14_PIN);
            g_u8sensorStatus[HS59] = GPIO_PinRead(BOARD_INITPINS_IRIN15_PORT,BOARD_INITPINS_IRIN15_PIN);
            g_u8sensorStatus[HS63] = GPIO_PinRead(BOARD_INITPINS_IRIN16_PORT,BOARD_INITPINS_IRIN16_PIN);            
			GPIO_PinWrite(BOARD_INITPINS_IRS0_PORT, BOARD_INITPINS_IRS0_PIN,0);	
			GPIO_PinWrite(BOARD_INITPINS_IRS1_PORT, BOARD_INITPINS_IRS1_PIN,0);	
			break;
		case 1:            
			//读取S1=0,S0=0
            g_u8sensorStatus[HS04] = GPIO_PinRead(BOARD_INITPINS_IRIN1_PORT,BOARD_INITPINS_IRIN1_PIN);
            g_u8sensorStatus[HS39] = GPIO_PinRead(BOARD_INITPINS_IRIN2_PORT,BOARD_INITPINS_IRIN2_PIN);
            g_u8sensorStatus[HS10] = GPIO_PinRead(BOARD_INITPINS_IRIN3_PORT,BOARD_INITPINS_IRIN3_PIN);
            g_u8sensorStatus[HS14] = GPIO_PinRead(BOARD_INITPINS_IRIN4_PORT,BOARD_INITPINS_IRIN4_PIN);
            g_u8sensorStatus[HS17] = GPIO_PinRead(BOARD_INITPINS_IRIN5_PORT,BOARD_INITPINS_IRIN5_PIN);
            g_u8sensorStatus[HS21] = GPIO_PinRead(BOARD_INITPINS_IRIN6_PORT,BOARD_INITPINS_IRIN6_PIN);
            g_u8sensorStatus[HS25] = GPIO_PinRead(BOARD_INITPINS_IRIN7_PORT,BOARD_INITPINS_IRIN7_PIN);
            g_u8sensorStatus[HS29] = GPIO_PinRead(BOARD_INITPINS_IRIN8_PORT,BOARD_INITPINS_IRIN8_PIN);
            g_u8sensorStatus[HS01] = GPIO_PinRead(BOARD_INITPINS_IRIN9_PORT,BOARD_INITPINS_IRIN9_PIN);
            g_u8sensorStatus[HS34] = GPIO_PinRead(BOARD_INITPINS_IRIN10_PORT,BOARD_INITPINS_IRIN10_PIN);
            g_u8sensorStatus[HS07] = GPIO_PinRead(BOARD_INITPINS_IRIN11_PORT,BOARD_INITPINS_IRIN11_PIN);
            g_u8sensorStatus[HS44] = GPIO_PinRead(BOARD_INITPINS_IRIN12_PORT,BOARD_INITPINS_IRIN12_PIN);
            g_u8sensorStatus[HS48] = GPIO_PinRead(BOARD_INITPINS_IRIN13_PORT,BOARD_INITPINS_IRIN13_PIN);
            g_u8sensorStatus[HS52] = GPIO_PinRead(BOARD_INITPINS_IRIN14_PORT,BOARD_INITPINS_IRIN14_PIN);
            g_u8sensorStatus[HS16] = GPIO_PinRead(BOARD_INITPINS_IRIN15_PORT,BOARD_INITPINS_IRIN15_PIN);
            g_u8sensorStatus[HS61] = GPIO_PinRead(BOARD_INITPINS_IRIN16_PORT,BOARD_INITPINS_IRIN16_PIN);                        
			GPIO_PinWrite(BOARD_INITPINS_IRS0_PORT, BOARD_INITPINS_IRS0_PIN,0);	
			GPIO_PinWrite(BOARD_INITPINS_IRS1_PORT, BOARD_INITPINS_IRS1_PIN,1);	
			break;
		case 2:
		    //读取S1=1,S0=0
            g_u8sensorStatus[HS05] = GPIO_PinRead(BOARD_INITPINS_IRIN1_PORT,BOARD_INITPINS_IRIN1_PIN);
            g_u8sensorStatus[HS40] = GPIO_PinRead(BOARD_INITPINS_IRIN2_PORT,BOARD_INITPINS_IRIN2_PIN);
            g_u8sensorStatus[HS11] = GPIO_PinRead(BOARD_INITPINS_IRIN3_PORT,BOARD_INITPINS_IRIN3_PIN);
            g_u8sensorStatus[HS15] = GPIO_PinRead(BOARD_INITPINS_IRIN4_PORT,BOARD_INITPINS_IRIN4_PIN);
            g_u8sensorStatus[HS18] = GPIO_PinRead(BOARD_INITPINS_IRIN5_PORT,BOARD_INITPINS_IRIN5_PIN);
            g_u8sensorStatus[HS22] = GPIO_PinRead(BOARD_INITPINS_IRIN6_PORT,BOARD_INITPINS_IRIN6_PIN);
            g_u8sensorStatus[HS26] = GPIO_PinRead(BOARD_INITPINS_IRIN7_PORT,BOARD_INITPINS_IRIN7_PIN);
            g_u8sensorStatus[HS30] = GPIO_PinRead(BOARD_INITPINS_IRIN8_PORT,BOARD_INITPINS_IRIN8_PIN);
            g_u8sensorStatus[HS02] = GPIO_PinRead(BOARD_INITPINS_IRIN9_PORT,BOARD_INITPINS_IRIN9_PIN);
            g_u8sensorStatus[HS35] = GPIO_PinRead(BOARD_INITPINS_IRIN10_PORT,BOARD_INITPINS_IRIN10_PIN);
            g_u8sensorStatus[HS08] = GPIO_PinRead(BOARD_INITPINS_IRIN11_PORT,BOARD_INITPINS_IRIN11_PIN);
            g_u8sensorStatus[HS45] = GPIO_PinRead(BOARD_INITPINS_IRIN12_PORT,BOARD_INITPINS_IRIN12_PIN);
            g_u8sensorStatus[HS49] = GPIO_PinRead(BOARD_INITPINS_IRIN13_PORT,BOARD_INITPINS_IRIN13_PIN);
            g_u8sensorStatus[HS53] = GPIO_PinRead(BOARD_INITPINS_IRIN14_PORT,BOARD_INITPINS_IRIN14_PIN);
            g_u8sensorStatus[HS58] = GPIO_PinRead(BOARD_INITPINS_IRIN15_PORT,BOARD_INITPINS_IRIN15_PIN);
            g_u8sensorStatus[HS62] = GPIO_PinRead(BOARD_INITPINS_IRIN16_PORT,BOARD_INITPINS_IRIN16_PIN);            
			GPIO_PinWrite(BOARD_INITPINS_IRS0_PORT, BOARD_INITPINS_IRS0_PIN,1);	
			GPIO_PinWrite(BOARD_INITPINS_IRS1_PORT, BOARD_INITPINS_IRS1_PIN,1);	
			break;
		case 3:   
			//读取S1=1,S0=1        
            g_u8sensorStatus[HS38] = GPIO_PinRead(BOARD_INITPINS_IRIN1_PORT,BOARD_INITPINS_IRIN1_PIN);
            g_u8sensorStatus[HS42] = GPIO_PinRead(BOARD_INITPINS_IRIN2_PORT,BOARD_INITPINS_IRIN2_PIN);
            g_u8sensorStatus[HS13] = GPIO_PinRead(BOARD_INITPINS_IRIN3_PORT,BOARD_INITPINS_IRIN3_PIN);
            g_u8sensorStatus[HS57] = GPIO_PinRead(BOARD_INITPINS_IRIN4_PORT,BOARD_INITPINS_IRIN4_PIN);
            g_u8sensorStatus[HS20] = GPIO_PinRead(BOARD_INITPINS_IRIN5_PORT,BOARD_INITPINS_IRIN5_PIN);
            g_u8sensorStatus[HS24] = GPIO_PinRead(BOARD_INITPINS_IRIN6_PORT,BOARD_INITPINS_IRIN6_PIN);
            g_u8sensorStatus[HS28] = GPIO_PinRead(BOARD_INITPINS_IRIN7_PORT,BOARD_INITPINS_IRIN7_PIN);
            g_u8sensorStatus[HS32] = GPIO_PinRead(BOARD_INITPINS_IRIN8_PORT,BOARD_INITPINS_IRIN8_PIN);
            g_u8sensorStatus[HS33] = GPIO_PinRead(BOARD_INITPINS_IRIN9_PORT,BOARD_INITPINS_IRIN9_PIN);
            g_u8sensorStatus[HS37] = GPIO_PinRead(BOARD_INITPINS_IRIN10_PORT,BOARD_INITPINS_IRIN10_PIN);
            g_u8sensorStatus[HS43] = GPIO_PinRead(BOARD_INITPINS_IRIN11_PORT,BOARD_INITPINS_IRIN11_PIN);
            g_u8sensorStatus[HS47] = GPIO_PinRead(BOARD_INITPINS_IRIN12_PORT,BOARD_INITPINS_IRIN12_PIN);
            g_u8sensorStatus[HS51] = GPIO_PinRead(BOARD_INITPINS_IRIN13_PORT,BOARD_INITPINS_IRIN13_PIN);
            g_u8sensorStatus[HS55] = GPIO_PinRead(BOARD_INITPINS_IRIN14_PORT,BOARD_INITPINS_IRIN14_PIN);
            g_u8sensorStatus[HS60] = GPIO_PinRead(BOARD_INITPINS_IRIN15_PORT,BOARD_INITPINS_IRIN15_PIN);
            g_u8sensorStatus[HS64] = GPIO_PinRead(BOARD_INITPINS_IRIN16_PORT,BOARD_INITPINS_IRIN16_PIN);
			GPIO_PinWrite(BOARD_INITPINS_IRS0_PORT, BOARD_INITPINS_IRS0_PIN,1);	
			GPIO_PinWrite(BOARD_INITPINS_IRS1_PORT, BOARD_INITPINS_IRS1_PIN,0);	
			break;
		default:
			break;
	}
	renew_flag = 0;
}

/产品有64个数字红外传感器，传感器的状态有两种，0或1，使用结构体位域，在节省内存的同时还方便阅读。
这个定义在中间层，应用层调用中间层，驱动层负责获取传感器的状态并赋值给这个结构体。/

struct ir_sensor
{
	uint32_t s001:1;
	uint32_t s002:1;
	uint32_t s003:1;
	uint32_t s004:1;
	uint32_t s005:1;
	uint32_t s006:1;
	uint32_t s007:1;
	uint32_t s008:1;
	uint32_t s009:1;
	uint32_t s010:1;
	uint32_t s011:1;
	uint32_t s012:1;
	uint32_t s013:1;
	uint32_t s014:1;
	uint32_t s017:1;
	uint32_t s018:1;
	uint32_t s019:1;
	uint32_t s020:1;
	uint32_t s014:1;
	uint32_t s001:1;
	uint32_t s102:1;
	uint32_t s103:1;
	uint32_t s104:1;
	uint32_t s201:1;
	uint32_t s202:1;
	uint32_t s203:1;
	uint32_t s204:1;
	uint32_t s205:1;
	uint32_t s206:1;
	uint32_t s301:1;
	uint32_t s302:1;	
	uint32_t s303:1;
	uint32_t s401:1;
	uint32_t s402:1;
	uint32_t s403:1;
	uint32_t s404:1;
	uint32_t s405:1;
	uint32_t s406:1;
	uint32_t s407:1;
	uint32_t s408:1;
	uint32_t s410:1;
	uint32_t s411:1;
	uint32_t s412:1;	
	uint32_t s511:1;
	uint32_t s512:1;
	uint32_t s513:1;
	uint32_t s521:1;
	uint32_t s522:1;
	uint32_t s523:1;
	uint32_t s611:1;
	uint32_t s612:1;
	uint32_t s613:1;
	uint32_t s621:1;
	uint32_t s622:1;
	uint32_t s623:1;
	uint32_t s500:1;
	uint32_t ss01:1;
	uint32_t sf01:1;
	uint32_t sb01:1;
	uint32_t sb02:1;
	uint32_t sw01:1;
	uint32_t sab1:1;
}

//周期性更新数字红外传感器状态到中间层，1ms调用一次
struct ir_sensor g_irSensor;
void get_irsensor_status(void)
{
	uint8_t i,l_u8sensorStatus[HS_NUM];
	if( renew_flag ) return;
	for(i=0;i<HS_NUM;i++)
	{
		l_u8sensorStatus[i] = g_u8sensorStatus[i];
	}
	g_irSensor.s001 = l_u8sensorStatus[HS01];
}