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

最新推荐文章于 2024-04-24 16:29:13 发布
最新推荐文章于 2024-04-24 16:29:13 发布
阅读量373 收藏 6
点赞数 8
分类专栏： C 文章标签： 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sscb0521/article/details/132538641
版权

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];
}
sscb0521
关注
  • 8
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
结构体位域说明
11-23
结构体位域说明 结构体位域说明 结构体位域说明
C语言结构体之位域详解
07-25
文章主要对C语言结构体的位域知识进行详细介绍。
基于Simulink实现CAN报文解析(unpack)与打包(pack)任务
RichardsZ_的博客
06-12 1万+
CAN报文解析   在如今的汽车电子中，常用到雷达，激光雷达等多种传感器。传感器各种信号根据其信号长度与编码类型，打包成CAN报文发送到控制器，则控制器需要做出解析。   如下图所示：一帧CAN报文里可存放许多信号（各信号根据长度，编码格式“塞”进CAN报文） Simulink CAN UNPACK使用   首先unpack模块需要接入CAN_MSG，这里可以拉取一个CAN_Receive模块来作为unpack的输入。下一步，配置CAN_Conf
c语言编程（1）—— 枚举、结构体、共用体
m0_60337039的博客
02-15 577
c语言编程中的复杂数据类型，以及位域和cpu储存方式简介
Redis学习总结(基本数据类型 底层结构)
最新发布
阿七的博客
04-24 696
基本用法SET存储字符串值。SETNX仅在键不存在的情况下存储字符串值。用于实现锁。GET检索字符串值。MGET在单个操作中检索多个字符串值。key - value键值对，底层数据结构是SDS简单动态字符。详细来说的话，底层有三种编码方式，int，embstr，raw其中int存储的是long型数据，其他两个都用sds，不过embstr编码的sds是最结构效率最快的。应用场景。??
嵌入式Linux驱动笔记(十七)------详解V4L2框架(UVC驱动)
风筝
11-18 1万+
你好！这里是风筝的博客，欢迎和我一起交流。Video for Linux 2，简称V4l2，是Linux内核中关于视频设备的内核驱动框架，为上层的访问底层的视频设备提供了统一的接口。凡是内核中的子系统都有抽象底层硬件的差异，为上层提供统一的接口和提取出公共代码避免代码冗余等好处。首先来看看所有的v4l2驱动都必须要有的几个组成部分： – 用来描述每一个v4l2设备实例状态的结构(struct v4
Effective Modern C++42招独家技巧助你改善C++11和C++14的高效用法笔记
网络资源是无限的
02-01 9605
Scott Meyers大师Effective三部曲：Effective C++、More Effective C++、Effective STL，这三本书出版已很多年，后来又出版了Effective Modern C++。 Effective C++的笔记见：https://blog.csdn.net/fengbingchun/article/details/102761542 More E...
Linux进程调度器的设计--Linux进程的管理与调度(十七）
热门推荐
OSKernelLAB(gatieme)
06-17 2万+
日期 内核版本 架构 作者 GitHub CSDN 2016-06-14 Linux-4.6 X86 & arm gatieme LinuxDeviceDrivers Linux进程管理与调度 1 前景回顾1.1 进程调度内存中保存了对每个进程的唯一描述, 并通过若干结构与其他进程连接起来.调度器面对的情形就是这样, 其任务是在程序之间共享CPU时间,
05 C语言框架讲解(嵌入式C语言要学哪些内容，学习路线)
qq582880551的博客
07-23 2227
define宏定义函数示例代码#井号在宏定义中将变量名转成字符串，##两个井号将两个变量名或字符串拼接成一个字符串。typedef在结构体struct命名、enum命名中很使用、在函数指针定义中也很好用。// typedef用法1 typedef struct _TMP_T {int a;} TMP_T;// typedef用法2 typedef void(* PFUNC)(void);
嵌入式工程师常见面试题（持续更新版本）
black_sneak的博客
07-06 2万+
嵌入式工程师常见的高频面试题（持续更新版本）
C语言技能数（知识点汇总）
奇妙的代码
03-18 1724
C语言是一门面向过程的计算机编程语言，与C++、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。C语言描述问题比汇编语言迅速、工作量小、可读性好、易于调试、修改和移植，而代码质量与汇编语言相当。C语言一般只比汇编语言代码生成的目标程序效率低10%～20%。因此，C语言可以编写系统软件。
C 结构体位域.docx
09-10
所谓“位域”是把一个字节中的二进位划分为几 个不同的区域，并说明每个区域的位数。本文档用例子描述了C结构体位域的应用，简单易懂，相信初学者很快就能掌握。
将结构体保存到文件
03-08
这个类可以将结构体保存到文件，声明结构体的时候必须使用()>标记为可序列化
利用串口传输结构体数据
01-06
结构体是一种数据的归类方式，相比数组或变量更具有整体全面性，例如一个数组只可以放一些按照元素顺序存放的单元变量，即 buffer = {x, x, x, x, x…}，i 有多大，数组内元素就有多少。那么我们这时候如果我们用这...
无符号数相减溢出
sscb0521的博客
04-23 4847
u16 a=190;u16 b=1020;u16 c=0;c=a-b;c=0xfcc2;单片机采用补码运算，需要程序员认为识别是有符号数还是无符号数。通过最高bit判断。//相差不大取上一次的值if(Fluor_Value_100x_backup!=Fluor_Value_100x){ //用减法处理会有溢出情况 if((Fluor_...
C语言打印文件名、函数名、行号、时间信息
sscb0521的博客
02-28 955
_FUNCTION__ or __func__：函数名(字符串)__LINE__：当前打印函数所在的行号(整型数据)__DATE__：当前日期（和系统有关，是字符串）__TIME__：实时时间(字符串)1. 标准库中一些特殊的宏。__FILE__：文件名(
Modbus-CRC16查表法
sscb0521的博客
08-20 470
Modbus-CRC16的初始值是0xFFFF,多项式是0x8005。
C语言-常用函数
sscb0521的博客
02-28 337
5、取较小值，较大值。
c语言结构体位域赋值
08-29
C语言中的结构体位域是一种用来优化存储空间的技术。位域允许我们在一个字节（byte）中存储多个不同长度的变量。 要给结构体位域赋值，我们首先要定义一个包含位域的结构体。下面是一个示例： ```c #include <stdio.h> struct Student { int id: 8; // 8位表示学生ID int age: 6; // 6位表示学生年龄 int gender: 1; // 1位表示学生性别（0表示男性，1表示女性） }; int main() { struct Student student1; student1.id = 10; student1.age = 20; student1.gender = 1; printf("学生ID：%d\n", student1.id); printf("学生年龄：%d\n", student1.age); printf("学生性别：%s\n", student1.gender == 0 ? "男" : "女"); return 0; } ``` 在上面的代码中，我们定义了一个包含三个位域的结构体Student。我们可以通过设置每个位域的值来为整个结构体赋值。 在main函数中，我们首先声明一个Student类型的结构体student1。然后，我们为每个位域设置了具体的值。 最后，我们使用printf函数输出了学生的ID、年龄和性别。 需要注意的是，位域的长度必须小于或等于所属数据类型的长度。如果位域长度超过了所属数据类型的长度，则会发生溢出。 通过使用结构体位域，我们可以有效地利用存储空间，提高程序的性能。在实际应用中，我们可以根据自己的需求来自定义结构体的位域，以便最大限度地优化存储空间。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值