drivers_day17

最新推荐文章于 2024-08-01 09:18:28 发布
最新推荐文章于 2024-08-01 09:18:28 发布
阅读量325 收藏 1
点赞数
分类专栏： 驱动编程
本文介绍Linux内核I2C驱动实现方法及Input子系统架构，涵盖I2C驱动框架、SMBUS接口原理、I2C总线驱动细节、按键驱动设计等内容。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

回顾：

1.linux内核I2C驱动实现

GPIO模拟I2C的时序来实现；

直接操作I2C控制器来实现；

采用linux内核的I2C驱动框架来实现；

 

linux内核I2C驱动框架：

应用层：open,read,write,ioctl访问I2C外设

      eeprom.addr //外设的片内地址

      eeprom.data //外设访问的数据

--------------------------------------------------

      I2C设备驱动

      i2c_client->i2c_board_info

      i2c_driver

      1.获取用户要访问的片内地址和数据

      2.I2C设备驱动只关心设备操作的数据信息，不关心数据是如何通过硬件传输的；

      3.利用内核提供的SMBUS接口将数据信息丢给底层的I2C总线驱动，由I2C总线驱动来实现I2C硬件传输；

________________________________________________

      SMBUB接口：

      本质：就是I2C设备驱动和I2C总线驱动的桥梁

      目标：给I2C设备驱动使用！用于将I2C设备驱动获取的数据信息（设备地址，片内地址，数据）丢给I2C总线驱动

----------------------------------------------------------   

      I2C总线驱动

      1.I2C总线驱动不关心数据的信息，只关注硬件的I2C总线数据的传输；

      2.数据信息来自I2C设备驱动

      3.操作的硬件是I2C控制器甚至用GPIO模拟的I2C控制器（i2c-gpio.c）；

 

2.一线式总线，DS18B20

一根数据线；无时钟线和其他控制信号线

总线；

三线，二线；

上拉电阻；

一线式总线数据传输协议：以DS18B20数字温度传感器为例

1.DS18B20硬件特性；

2.操作步骤：三步骤

三步骤的操作关键涉及数据的传输问题，由于没有时钟线，只能在数据线上做文章（时序）；

 

*********************************************************

linux老式字符设备驱动注册和卸载：

注册字符设备：

int register_chrdev(intmajor, char *name, struct file_operations *fops);

卸载字符设备：

intunregister_chrdev(int majro, char *name);

以上方法仅仅是注册字符设备和卸载字符设备，设备文件还需单独创建！

 

**********************************************************

linux内核input子系统：

管理的硬件设备对象：键盘，鼠标，触摸屏，按键，游戏摇杆，compass传感器，温度传感器等，只是前5个设备是标准的输入设备！

     设备         有效数据信息(用户关心)

键盘，按键       键值和按键的状态（按下或者松开）

触摸屏        X,Y绝对坐标和触摸屏的状态（按下，松                         开）

鼠标           X,Y相对坐标，左右两个按键值和按键的              状态，还有滚轮的方向和滚轮的按下，松              开

compass传感器 X,Y值

温度传感器       温度值

总结：有效的数据信息最终来自硬件设备本身！

 

linux内核input子系统的软件分层框架：

应用层：app1    app2

              open,read,write,ioctl...

设备文件：由核心层创建

按键设备文件/dev/input/event0或者/dev/event0

触摸屏设备文件/dev/input/event1或者/dev/event1

鼠标的设备文件/dev/input/event2或者/dev/event2

...

------------------------------------------------

核心层：drivers/input/input.c

作用：它是应用层和底层硬件设备驱动的桥梁，可以做标准

用户访问设备不是直接，而是间接（由核心层做中转）；

任务：

1.核心层要给应用层提供一个统一的访问硬件设备的操作接口，也就代表如果这个硬件按照input子系统的软件框架来实现，那么所有的应用程序访问这个设备，最终都会调用核心层的这个接口；

核心层提供的统一操作接口如下：

static conststruct file_operations evdev_fops = {

      .owner        =THIS_MODULE,

      .read          =evdev_read,//读设备

      .write         =evdev_write,//写设备

      .poll           =evdev_poll, //监听设备

      .open         =evdev_open,//打开设备

      .release =evdev_release,//关闭设备

      .unlocked_ioctl   = evdev_ioctl, //控制设备

};

明确：所有的应用程序访问input子系统的设备，最终都会调用evdev_fops提供的函数！

 

2.

核心层给底层设备驱动提供相关函数和一个结构体用于将底层硬件设备硬件信息注册到核心层去，供核心层的操作接口去使用！

明确：这里说的“硬件信息”：是用户最终要关心的硬件信息，例如如果是按键，这个硬件信息是键值和按键的状态，如果是触摸屏，这个硬件信息是坐标和触摸屏的操作状态，不关心这个硬件信息来自于具体的硬件，不关心硬件如何连接和触发！底层硬件的具体操作例如申请GPIO，注册中断，中断处理函数等等都有驱动来实现。

 

结构体：

structinput_dev;

函数：

intinput_register_device(struct input_dev *dev);

intinput_event(struct input_dev *dev,

           int type, int code, int value);

总结：底层设备驱动利用上面的结构体和函数就可以将硬件的有效数据信息注册到核心层；

----------------------------------------------------

设备驱动层：只关注硬件

1.关注实际的硬件信息:使用哪个GPIO，使用哪个中断，使用哪个物理地址等

2.GPIO申请，中断的申请，地址映射等

3.利用核心层提供的结构体和函数注册有效的数据信息到核心层

4.每当硬件上发生变化（产生中断），底层驱动获取有效的硬件信息，将有效的信息信息提交给核心层去

----------------------------------------------------

按键设备驱动    触摸屏设备驱动   鼠标设备驱动 ...

（input_dev） input_dev      input_dev

总结：一个硬件设备对应一个struct input_dev,在用户空间也对应一个设备文件/dev/input/eventx(x=0,1,2,...)

 

问：如何利用内核提供的input子系统框架，实现一个input子系统的按键驱动？

答：关键底层驱动围绕着一个结构体和两个函数；

一个结构体：

struct input_dev{

const char*name;//指示当前硬件设备名称

//最终给用户上报的事件类型，间接告诉用户将来这个事件对应的有效的数据信息是什么（例如按键值或者坐标），注意在使用input_dev时，一定要将上报的事件类型进行初始化，给核心层使用，将来核心层会检查这个位图对应的位置是否进行被初始化。内核常用的事件有如下：

#define EV_KEY 0x01 //按键类事件

#define EV_REL 0x02//相对位移坐标事件

#define EV_ABS 0x03//绝对位移坐标事件

#define EV_MSC 0x04//混杂设备事件

#define EV_REP 0x14 //重复类事件

unsigned longevbit[BITS_TO_LONGS(EV_CNT)];

例如：set_bit(EV_KEY, evbit); //上报按键类事件

 

//按键类事件中的哪些按键值需要进行上报，如果要指定某个上报的按键，需要将按键对应的位图位置值1，将来核心层会检查

unsigned longkeybit[BITS_TO_LONGS(KEY_CNT)];

例如：set_bit(KEY_UP, keybit); //将来要上报KEY_UP键值

 

//绝对位移坐标事件中的哪些信息（坐标信息）需要上报,如果要上报某个坐标，需要将对应的位图位置置1，核心层会检查

unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];

例如：set_bit(ABS_X, absbit); //将来要上报X坐标值

set_bit(ABS_Y,absbit); //将来要上报Y坐标值

};

 

结构体如何使用？

1.分配struct input_dev对象，代表一个硬件设备

   struct input_dev *input =input_allocate_device();

2.初始化input_dev对象

    input->name = "tarena"; //指定设备的名称

    set_bit(EV_ABS, input->evbit);//将来会上报绝对位移坐标                        事件

    set_bit(ABS_X, input->absbit);//将来会上报X坐标值

    set_bit(ABS_Y, input->absbit);//将来会上报Y坐标值

    set_bit(ABS_PRESSURE, input->absbit);//将来上报压力                            值

    set_bit(EV_KEY, input->evbit);//将来上报触摸屏的操作状                   态

    set_bit(BTN_TOUCH,input->keybit);//触摸屏上报的键值

3.向核心层注册input_dev对象

   input_register_device(input_dev);

注意再注意：

3.1一旦注册input_dev对象成功，核心层会为这个设备在用户空间创建一个对应的设备文件（/dev/input/eventx）。

3.2本质是向核心层注册硬件设备将来要上报的有效数据信息

 

4.卸载input_dev对象

   input_unregister_device(input); //删除设备文件

 

5.释放input_dev对象

input_free_device(input);

 

6.如何将有效的数据信息上报给核心层呢？

利用input_event函数

intinput_event(struct input_dev *dev,

           int type, int code, int value);

功能：一旦硬件设备驱动发现设备或者数据可用，底层驱动利用此函数可以将设备的有效数据信息上报给核心层。例如，如果设备驱动的中断处理函数被内核调用，表明硬件有操作，产生中断，此时即可上报数据信息；

参数：

dev:指向分配的input_dev对象

type:上报的事件类型，例如EV_KEY,EV_REP...

code:KEY_1,KEY_2,ABS_X,ABS_Y...

value:

如果是按键：value的值为：按下为1，松开为0

如果是坐标：坐标值

 

7.核心层获取底层驱动上报的数据信息以后，如何将数据信息递交给用户呢，这里用户和核心层使用同一个结构体来实现数据的传递：

structinput_event {

      struct timeval time; //事件触发时间

      __u16 type; //事件类型，EV_KEY,EV_ABS

      __u16 code; //对应事件类型的位图位置，键值

      __s32 value;//按键状态或者坐标值

};

用户使用结构体需包含头文件#include <linux/input.h>

 

实验步骤：

1.insmodbtn_drv.ko

2.cat/proc/interrupts //查看中断的注册信息

3.cat/proc/bus/input/devices //查看按键的设备文件

 I: Bus=0000 Vendor=0000 Product=0000Version=0000

N:Name="tarena_button"

P: Phys=

S:Sysfs=/devices/virtual/input/input3

U: Uniq=

H: Handlers=kbdevent3 （最终设备文件为/dev/event3或者/dev/input/event3）

B: EV=100003

B: KEY=1680 0 00

 

4.读取按键信息（事件类型，键值，按键状态）

./btn_test/dev/event3 或者./btn_test/dev/input/event3

 

5.运行贪吃蛇或者俄罗斯方块游戏

PC编译：

/opt/project/qt/bin/qmake-project

/opt/project/qt/bin/qmake

make

 

添加QT对开发板按键的支持：

vim/opt/rootfs/etc/profile中添加：

exportQWS_KEYBOARD="TTY:/dev/event3" //注       意/dev/event3或者/dev/input/event3是按键的设备文件

重启开发板

运行游戏，通过上下左右来操作

 

//查看触摸屏的设备文件

hexdump/dev/input/event0开始一个个试，按屏幕看打印

别忘记修改profile文件指定触摸屏的设备文件

 

QT中文乱码解决方法：

vim main.cpp添加如下语句：

#include<QTextCodec>

QTextCodec::setCodecForCStrings(QTextCodec::codecForName("gb2312"));

 

QTextCodec::setCodecForLocale(QTextCodec::codecForName("gb2312"));

 

********************************************************************

按键硬件设计：

独立式按键，例如100按键，需要100个IO

      缺点：浪费IO资源，优点：软件操作简单

矩阵式按键，例如100按键，需要20个IO(10*10)

      缺点：软件操作复杂，优点：省IO资源

按键去抖动：

产生的原因：按键本身就是机械结构

如何去抖动：

硬件去抖动

      滤波电路，成本高

软件去抖动

      抖动产生的触发沿下降沿和上升沿之间的时间间隔为一个经验值5~10ms

      单片机：采用忙延时，for循环

      linux内核：采用定时器实现（struct timer_list）

 

 

 

 

 

【黑马甄选离线数仓day01_项目介绍与环境准备】
LKL的博客
11-22 1614
项目介绍与环境准备
drivers_day02
ppw001的专栏
04-01 402
回顾： 1.回顾嵌入式linux系统相关内容 2.linux系统分为用户空间和内核空间 用户空间：       CPU的工作模式为：USR（用户）模式，也是非特权模式       运行：应用程序，C库等       地址空间：4G虚拟地址空间，占前3G       地址范围：0x00000000~0xBFFFFFFF       不能直接访问硬件资源，不能访问内核空间地址 内核空
Note_Spark_Day01：Spark 基础环境
Maynor的博客
07-04 807
stypora-copy-images-to: img typora-root-url: ./ Spark Day01：Spark 基础环境 预习视频： https://www.bilibili.com/video/BV1uT4y1F7ap Spark：基于Scala语言 Flink：基于Java语言 01-[了解]-Spark 课程安排 总的来说分为Spark 基础环境、Spark 离线分析和Spark实时分析三个大的方面，如下图所示： 目前在企业中使用最多Spark框架中模块：Spa.
DAY17
C7523的博客
08-01 800
2. 修改 nginx.conf 中的 server 模块中的 server_name 将域名修改为 ip 地。sed -n 'server 的行号 p' /usr/local/nginx/conf/nginx.conf。sed -i 'server 的行号 d' /usr/local/nginx/conf/nginx.conf。devops.conf 文件中 4. 删除 nginx.conf 中原有的自定义 server 模块。3. 将在 nginx.conf 文件中创建的 server 复制到。
Day17
2301_80669664的博客
07-31 698
2. 修改 nginx.conf 中的 server 模块中的 server_name 将域名修改为 ip 地。sed -n 'server 的行号 p' /usr/local/nginx/conf/nginx.conf。sed -i 'server 的行号 d' /usr/local/nginx/conf/nginx.conf。devops.conf 文件中 4. 删除 nginx.conf 中原有的自定义 server 模块。3. 将在 nginx.conf 文件中创建的 server 复制到。
云计算day17
m0_67484044的博客
07-31 830
虚拟主机
Day 23 What Drivers You Crazy
cyl1234day的博客
06-26 274
Hi, I’m Vanessa from speakenglishwithvanessa.com. Today, I’d like to tell you a story about something that drives me crazy. Let’s get started. As many of you know, during the month of May, 2015, I was working really hard, creating the course “30 days of En
Spark_Day01：Spark 框架概述和Spark 快速入门
Maynor的博客
07-24 642
Spark Day01：Spark 基础环境 预习视频： https://www.bilibili.com/video/BV1uT4y1F7ap Spark：基于Scala语言 Flink：基于Java语言 01-[了解]-Spark 课程安排 总的来说分为Spark 基础环境、Spark 离线分析和Spark实时分析三个大的方面，如下图所示： 目前在企业中使用最多Spark框架中模块：Spa.
python3 _笨方法学Python_日记_DAY1
weixin_33836223的博客
02-14 147
第四版 资源https://pan.baidu.com/s/1bqvf0Ov 从零开始！每个细节都要过 书中是根据python2.5写的 我用的是py3，顺便熟悉一下两者的区别 Day1 “习题一：第一个程序” print("hello world!") print("Hello again") print("I like typing this.") p...
JavaWeb-Day01
山野有雾灯
10-06 803
在java中，动态web资源的开发技术就统称为javaWeb!
day03_Nginx_图片上传
H197736的博客
03-23 1321
学习目标 使用域名访问本地项目 Nginx 图片上传 FastDFS实现图片上传 1.使用域名访问本地项目 1.1.统一环境 我们现在访问页面使用的是：http://localhost:8080 有没有什么问题？ 实际开发中，会有不同的环境： 开发环境：自己的电脑 测试环境：提供给测试人员使用的环境 预发布环境：数据是和生成环境的数据一致，运行最新的项目代码进去测试 生产环境：项目最终发布上线的环境 如果不同环境使用不同的ip去访问，可能会出现一些问题。为了保证所有环境的一致，我们会在各种环境下都使
BGI graphics drivers 源码
03-22
BGI Drivers for Borland compilers, shareware, M.Day bgidrv.zip 76874 May 31 1989 Develop your own BGI device drivers bgifont.zip 59161 Jun 5 1989 BGI font editor (EGA) fix8x14b.zip 18877 Apr 6 ...
#include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include <avr/eeprom.h> #include <string.h> #define delay_ms(x) _delay_ms(x) // LCD 相关引脚定义 #define LCD_RS PC0 #define LCD_RW PC1 #define LCD_E PC2 #define LCD_D4 PA4 #define LCD_D5 PA5 #define LCD_D6 PA6 #define LCD_D7 PA7 // 按键引脚定义（使用PORTD） #define SET_BUTTON PIND0 #define ADD_BUTTON PIND1 #define SUB_BUTTON PIND2 // LED 引脚定义 #define LED_PIN PB3 // EEPROM存储地址 #define EEPROM_TIME_HOUR_ADDR 0x00 #define EEPROM_TIME_MINUTE_ADDR 0x01 #define EEPROM_DATE_YEAR_ADDR 0x02 #define EEPROM_DATE_MONTH_ADDR 0x03 #define EEPROM_DATE_DAY_ADDR 0x04 // 全局变量 volatile uint8_t hour = 12; // 小时（0-23） volatile uint8_t minute = 0; // 分钟（0-59） volatile uint8_t second = 0; // 秒（0-59） volatile uint8_t year = 23; // 年份（后两位） volatile uint8_t month = 1; // 月份（1-12） volatile uint8_t day = 1; // 日期（1-31） volatile uint8_t set_mode = 0; // 0:正常显示, 1:设置小时, 2:设置分钟, 3:设置年, 4:设置月, 5:设置日 volatile uint8_t blink_state = 0; // 闪烁状态 volatile uint8_t timer1_counter = 0; // 定时器计数器 // 闹钟结构 typedef struct { uint8_t hour; uint8_t minute; uint8_t enabled; } Alarm; Alarm alarm1 = {8, 0, 0}; // 闹钟1，默认8:00，关闭 Alarm alarm2 = {12, 0, 0}; // 闹钟2，默认12:00，关闭 // LCD初始化 void LCD_Init() { // 设置数据端口为输出 DDRA |= (1<<LCD_D4) | (1<<LCD_D5) | (1<<LCD_D6) | (1<<LCD_D7); // 设置控制端口为输出 DDRC |= (1<<LCD_RS) | (1<<LCD_RW) | (1<<LCD_E); // 初始化序列 delay_ms(50); // 等待LCD上电稳定 // 4位模式初始化 LCD_Write_Command(0x33); LCD_Write_Command(0x32); LCD_Write_Command(0x28); // 4位模式，2行显示，5x8点阵 LCD_Write_Command(0x0C); // 显示开，光标关，闪烁关 LCD_Write_Command(0x06); // 增量模式，不移位 LCD_Write_Command(0x01); // 清屏 delay_ms(2); } // 向LCD发送命令 void LCD_Write_Command(unsigned char cmd) { PORTC &= ~(1<<LCD_RS); // RS=0 命令模式 PORTC &= ~(1<<LCD_RW); // RW=0 写入 // 发送高4位 PORTA = (PORTA & 0x0F) | (cmd & 0xF0); PORTC |= (1<<LCD_E); // E=1 delay_ms(1); PORTC &= ~(1<<LCD_E); // E=0 // 发送低4位 PORTA = (PORTA & 0x0F) | ((cmd << 4) & 0xF0); PORTC |= (1<<LCD_E); // E=1 delay_ms(1); PORTC &= ~(1<<LCD_E); // E=0 delay_ms(1); } // 向LCD发送数据 void LCD_Write_Data(unsigned char data) { PORTC |= (1<<LCD_RS); // RS=1 数据模式 PORTC &= ~(1<<LCD_RW); // RW=0 写入 // 发送高4位 PORTA = (PORTA & 0x0F) | (data & 0xF0); PORTC |= (1<<LCD_E); // E=1 delay_ms(1); PORTC &= ~(1<<LCD_E); // E=0 // 发送低4位 PORTA = (PORTA & 0x0F) | ((data << 4) & 0xF0); PORTC |= (1<<LCD_E); // E=1 delay_ms(1); PORTC &= ~(1<<LCD_E); // E=0 delay_ms(1); } // 在LCD上显示字符串 void LCD_Display_String(char *str) { while (*str) { LCD_Write_Data(*str++); } } // 设置LCD光标位置 void LCD_Set_Cursor(uint8_t row, uint8_t col) { uint8_t address; if (row == 0) { address = 0x80 + col; } else { address = 0xC0 + col; } LCD_Write_Command(address); } // 显示时间 void Display_Time() { char buffer[16]; // 第一行显示时间 LCD_Set_Cursor(0, 4); sprintf(buffer, "%02d:%02d:%02d", hour, minute, second); LCD_Display_String(buffer); // 第二行显示日期 LCD_Set_Cursor(1, 4); sprintf(buffer, "20%02d-%02d-%02d", year, month, day); LCD_Display_String(buffer); } // 显示设置模式 void Display_Set_Mode() { char buffer[16]; LCD_Set_Cursor(0, 0); LCD_Display_String("Set:"); switch(set_mode) { case 1: // 设置小时 if(blink_state) { sprintf(buffer, "Hour: %02d", hour); } else { sprintf(buffer, "Hour: "); } break; case 2: // 设置分钟 if(blink_state) { sprintf(buffer, "Minute:%02d", minute); } else { sprintf(buffer, "Minute: "); } break; case 3: // 设置年 if(blink_state) { sprintf(buffer, "Year: 20%02d", year); } else { sprintf(buffer, "Year: "); } break; case 4: // 设置月 if(blink_state) { sprintf(buffer, "Month: %02d", month); } else { sprintf(buffer, "Month: "); } break; case 5: // 设置日 if(blink_state) { sprintf(buffer, "Day: %02d", day); } else { sprintf(buffer, "Day: "); } break; default: sprintf(buffer, "Normal Mode "); } LCD_Set_Cursor(0, 5); LCD_Display_String(buffer); // 仍然显示时间日期 LCD_Set_Cursor(1, 0); sprintf(buffer, "Time:%02d:%02d:%02d", hour, minute, second); LCD_Display_String(buffer); } // 从EEPROM加载时间日期 void Load_Time_From_EEPROM() { hour = eeprom_read_byte((uint8_t*)EEPROM_TIME_HOUR_ADDR); minute = eeprom_read_byte((uint8_t*)EEPROM_TIME_MINUTE_ADDR); year = eeprom_read_byte((uint8_t*)EEPROM_DATE_YEAR_ADDR); month = eeprom_read_byte((uint8_t*)EEPROM_DATE_MONTH_ADDR); day = eeprom_read_byte((uint8_t*)EEPROM_DATE_DAY_ADDR); // 检查读取的值是否有效 if(hour > 23) hour = 0; if(minute > 59) minute = 0; if(year > 99) year = 23; if(month == 0 || month > 12) month = 1; if(day == 0 || day > 31) day = 1; } // 保存时间日期到EEPROM void Save_Time_To_EEPROM() { eeprom_update_byte((uint8_t*)EEPROM_TIME_HOUR_ADDR, hour); eeprom_update_byte((uint8_t*)EEPROM_TIME_MINUTE_ADDR, minute); eeprom_update_byte((uint8_t*)EEPROM_DATE_YEAR_ADDR, year); eeprom_update_byte((uint8_t*)EEPROM_DATE_MONTH_ADDR, month); eeprom_update_byte((uint8_t*)EEPROM_DATE_DAY_ADDR, day); } // 初始化定时器1 (1秒中断) void Timer1_Init() { // 设置定时器1为CTC模式 TCCR1B |= (1 << WGM12); // 设置预分频为1024 TCCR1B |= (1 << CS12) | (1 << CS10); // 设置比较值 (16MHz/1024 = 15625 ticks/sec, 15625 ticks = 1秒) OCR1A = 15625; // 启用比较匹配中断 TIMSK |= (1 << OCIE1A); } // 初始化按键引脚 void Buttons_Init() { // 设置按键引脚为输入，启用上拉电阻 DDRD &= ~((1<<SET_BUTTON) | (1<<ADD_BUTTON) | (1<<SUB_BUTTON)); PORTD |= (1<<SET_BUTTON) | (1<<ADD_BUTTON) | (1<<SUB_BUTTON); } // 按键扫描 void Key_Scan() { static uint8_t last_set_state = 1; static uint8_t last_add_state = 1; static uint8_t last_sub_state = 1; uint8_t current_set_state = PIND & (1<<SET_BUTTON); uint8_t current_add_state = PIND & (1<<ADD_BUTTON); uint8_t current_sub_state = PIND & (1<<SUB_BUTTON); // 检测设置按键按下 if(last_set_state && !current_set_state) { _delay_ms(20); // 消抖 if(!(PIND & (1<<SET_BUTTON))) { set_mode++; if(set_mode > 5) set_mode = 0; if(set_mode == 0) { // 退出设置模式，保存时间到EEPROM Save_Time_To_EEPROM(); } } } // 只在设置模式下检测加减按键 if(set_mode > 0) { // 检测增加按键按下 if(last_add_state && !current_add_state) { _delay_ms(20); // 消抖 if(!(PIND & (1<<ADD_BUTTON))) { switch(set_mode) { case 1: // 增加小时 hour = (hour + 1) % 24; break; case 2: // 增加分钟 minute = (minute + 1) % 60; break; case 3: // 增加年 year = (year + 1) % 100; break; case 4: // 增加月 month = (month % 12) + 1; break; case 5: // 增加日 day = (day % 31) + 1; break; } } } // 检测减少按键按下 if(last_sub_state && !current_sub_state) { _delay_ms(20); // 消抖 if(!(PIND & (1<<SUB_BUTTON))) { switch(set_mode) { case 1: // 减少小时 hour = (hour == 0) ? 23 : hour - 1; break; case 2: // 减少分钟 minute = (minute == 0) ? 59 : minute - 1; break; case 3: // 减少年 year = (year == 0) ? 99 : year - 1; break; case 4: // 减少月 month = (month == 1) ? 12 : month - 1; break; case 5: // 减少日 day = (day == 1) ? 31 : day - 1; break; } } } } last_set_state = current_set_state; last_add_state = current_add_state; last_sub_state = current_sub_state; } // 检查闹钟 void Check_Alarms() { static uint8_t alarm1_triggered = 0; static uint8_t alarm2_triggered = 0; // 检查闹钟1 if(alarm1.enabled && !alarm1_triggered && hour == alarm1.hour && minute == alarm1.minute && second == 0) { alarm1_triggered = 1; PORTB |= (1<<LED_PIN); // 打开LED } // 检查闹钟2 if(alarm2.enabled && !alarm2_triggered && hour == alarm2.hour && minute == alarm2.minute && second == 0) { alarm2_triggered = 1; PORTB |= (1<<LED_PIN); // 打开LED } // 每分钟重置闹钟触发标志 if(second == 0) { alarm1_triggered = 0; alarm2_triggered = 0; } // 如果LED亮起，检测按键关闭 if(PORTB & (1<<LED_PIN)) { if(!(PIND & (1<<SET_BUTTON)) || !(PIND & (1<<ADD_BUTTON)) || !(PIND & (1<<SUB_BUTTON))) { PORTB &= ~(1<<LED_PIN); // 关闭LED } } } // 定时器1比较匹配中断服务程序 ISR(TIMER1_COMPA_vect) { // 更新时间 second++; if(second >= 60) { second = 0; minute++; if(minute >= 60) { minute = 0; hour++; if(hour >= 24) { hour = 0; // 日期增加逻辑 day++; uint8_t max_day = 31; // 处理不同月份的天数 if(month == 4 || month == 6 || month == 9 || month == 11) { max_day = 30; } else if(month == 2) { // 简单处理2月天数（不考虑闰年） max_day = 28; } if(day > max_day) { day = 1; month++; if(month > 12) { month = 1; year++; if(year > 99) year = 0; } } } } } // 更新闪烁状态 (0.5秒周期) timer1_counter++; if(timer1_counter >= 5) { // 10次 = 1秒 (0.1秒中断) timer1_counter = 0; blink_state = !blink_state; } // 检查闹钟 Check_Alarms(); } int main(void) { // 初始化端口 DDRB |= (1<<LED_PIN); // LED引脚为输出 PORTB &= ~(1<<LED_PIN); // 初始关闭LED // 初始化按键 Buttons_Init(); // 初始化LCD LCD_Init(); // 从EEPROM加载时间 Load_Time_From_EEPROM(); // 初始化定时器 Timer1_Init(); // 启用全局中断 sei(); // 清屏并显示欢迎信息 LCD_Write_Command(0x01); LCD_Set_Cursor(0, 3); LCD_Display_String("AVR Clock"); LCD_Set_Cursor(1, 2); LCD_Display_String("Initializing..."); delay_ms(1000); LCD_Write_Command(0x01); while(1) { // 扫描按键 Key_Scan(); // 更新显示 if(set_mode == 0) { Display_Time(); } else { Display_Set_Mode(); } // 短暂延迟 delay_ms(100); } return 0; }使用的atmega128单片机，不改动引脚的使用
05-27
├── drivers │ ├── lcd.c │ └── rtc.c ├── services │ ├── time.c │ └── alarm.c └── main.c ``` 2. **状态机设计** 使用有限状态机管理设置流程： ```c typedef enum { ...
随机阻塞下毫米波通信的多波束功率分配”.zip
08-12
1.版本：matlab2014a/2019b/2024b 2.附赠案例数据可直接运行。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
基于分时电价与改进粒子群算法的电动汽车充放电优化调度策略研究
08-12
内容概要：本文探讨了基于分时电价和改进粒子群算法的电动汽车充放电优化调度策略。首先介绍了分时电价制度及其对电动汽车充放电的影响，随后详细解释了改进粒子群算法的工作原理以及如何应用于电动汽车的充放电调度。文中还提供了具体的Python代码实现，展示了如何通过定义电价信息、电池容量等参数并应用改进粒子群算法来找到最优的充电时间点。最后，文章总结了该方法的优势，并展望了未来的研究方向，如与智能电网和V2G技术的结合。 适合人群：对电动汽车充放电调度感兴趣的科研人员和技术开发者。 使用场景及目标：适用于希望优化电动汽车充放电策略以降低成本、提高电力系统效率的人群。主要目标是在不同电价时段内，通过智能调度实现最低成本或最高效率的充电。 其他说明：本文不仅提供理论分析，还有详细的代码实现，便于读者理解和实践。
步进电机脉冲精准计算方法
08-12
资源下载链接为： https://pan.quark.cn/s/d9ef5828b597 根据步进电机的步进角、脉冲总数、减速比以及丝杠导程，计算出实现直线行走距离为1mm所需的脉冲数量。
【CAD入门基础课程】3.7 综合实战-使用极轴追踪方式绘制信号灯.avi
最新发布
08-12
一、综合实战—使用极轴追踪方式绘制信号灯 实战目标：利用对象捕捉追踪和极轴追踪功能创建信号灯图形 技术要点：结合两种追踪方式实现精确绘图，适用于工程制图中需要精确定位的场景 1. 切换至AutoCAD 操作步骤： 启动AutoCAD 2016软件 打开随书光盘中的素材文件 确认工作空间为"草图与注释"模式 2. 绘图设置 1）草图设置对话框 打开方式：通过"工具→绘图设置"菜单命令 功能定位：该对话框包含捕捉、追踪等核心绘图辅助功能设置 2）对象捕捉设置 关键配置： 启用对象捕捉（F3快捷键） 启用对象捕捉追踪（F11快捷键） 勾选端点、中心、圆心、象限点等常用捕捉模式 追踪原理：命令执行时悬停光标可显示追踪矢量，再次悬停可停止追踪 3）极轴追踪设置 参数设置： 启用极轴追踪功能 设置角度增量为45度 确认后退出对话框 3. 绘制信号灯 1）绘制圆形 执行命令："绘图→圆→圆心、半径"命令 绘制过程： 使用对象捕捉追踪定位矩形中心作为圆心 输入半径值30并按Enter确认 通过象限点捕捉确保圆形位置准确 2）绘制直线 操作要点： 选择"绘图→直线"命令 捕捉矩形上边中点作为起点 捕捉圆的上象限点作为终点 按Enter结束当前直线命令 重复技巧： 按Enter可重复最近使用的直线命令 通过圆心捕捉和极轴追踪绘制放射状直线 最终形成完整的信号灯指示图案 3）完成绘制 验证要点： 检查所有直线是否准确连接圆心和象限点 确认极轴追踪的45度增量是否体现 保存绘图文件（快捷键Ctrl+S）
基于MATLAB的蒙特卡洛抽样在电动汽车充放电负荷计算中的应用研究
08-12
内容概要：本文探讨了利用蒙特卡洛抽样方法在MATLAB仿真平台上对大规模电动汽车的充放电负荷进行计算的方法。研究内容涵盖电动汽车充电功率、电池容量、起始充电时间及每日行驶里程的概率密度分布的抽样生成，并在此基础上计算充放电负荷。文中详细介绍了蒙特卡洛抽样方法及其在电动汽车参数抽样中的应用，同时提供了完整的MATLAB代码实现，包括数据准备、抽样、负荷计算及结果可视化。此外，代码注释详尽，出图效果优秀，有助于理解和学习。 适合人群：电力系统研究人员、电动汽车行业从业者、高校师生及相关领域的科研工作者。 使用场景及目标：适用于需要评估电动汽车对电网影响的研究项目，旨在提高电网规划和运行效率，确保电力系统的稳定性和可靠性。 其他说明：本文不仅提供了详细的理论解释和技术实现，还附带了高质量的MATLAB代码，便于读者直接上手实践并进行二次开发。
师生健康信息管理平台-师生健康信息管理平台源码-基于Web的师生健康信息管理平台设计与实现
08-12
师生健康信息管理-师生健康信息管理平台-师生健康信息管理平台源码-师生健康信息管理平台代码-springboot师生健康信息管理平台源码-基于springboot的师生健康信息管理平台设计与实现-代码
rtc_timestamp_struct
07-23
<think>我们注意到用户的问题是关于“rtc_timestamp_struct”的使用方法和配置示例。在之前的上下文中，我们讨论了GD32F5xx的RTC初始化，但用户现在提到的结构体名称可能有所不同。根据引用[1]和引用[3]的内容，我们得知在RT-Thread操作系统中，RTC驱动通常通过统一的接口进行操作，而时间戳可能以秒为单位（Unix时间戳格式）存储。但是，用户提到的“rtc_timestamp_struct”并不是RT-Thread的标准结构体。 在RT-Thread中，获取RTC时间通常使用`time_t`类型（即一个整数表示自1970年1月1日以来的秒数）。但是，有些驱动可能会定义自己的结构体来分解时间。例如，用户可能指的是一个包含年、月、日、时、分、秒等字段的结构体。 由于用户没有指定具体的硬件平台或RTOS，但根据引用[1][3][4]我们推测是在RT-Thread环境下，我们可以参考RT-Thread的RTC框架。 在RT-Thread中，标准的RTC操作接口包括： - 设置时间：`rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_SET_TIME, &time)` - 获取时间：`rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_GET_TIME, &time)` 其中，`time`是一个`time_t`类型的变量（即长整数）。 但是，如果用户需要分解的时间结构体，RT-Thread也提供了`struct tm`（定义在`time.h`中）用于分解时间。我们可以使用标准C库函数将`time_t`转换为`struct tm`，反之亦然。 因此，我们假设用户所说的“rtc_timestamp_struct”实际上是指`struct tm`。下面我们将介绍如何在RT-Thread中使用。 步骤： 1. 首先，确保已经开启了RTC设备驱动，并且在系统中注册了RTC设备（通常由驱动完成）。 2. 获取当前时间戳（秒数）并转换为`struct tm`结构体。 3. 或者，将`struct tm`结构体转换为时间戳并设置RTC。 示例代码： ```c #include <rtdevice.h> #include <time.h> void rtc_example(void) { rt_device_t rtc_dev; time_t now; // 1. 查找RTC设备 rtc_dev = rt_device_find("rtc"); if (rtc_dev == RT_NULL) { rt_kprintf("RTC device not found\n"); return; } // 2. 获取当前时间戳（秒） rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_GET_TIME, &now); // 3. 将时间戳转换为分解时间（struct tm） struct tm *timeinfo; timeinfo = localtime(&now); // 注意：localtime返回的是静态变量，非线程安全 rt_kprintf("Current time: %04d-%02d-%02d %02d:%02d:%02d\n", timeinfo->tm_year + 1900, timeinfo->tm_mon + 1, timeinfo->tm_mday, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec); // 4. 如果要设置RTC时间，可以先设置一个分解时间，再转换为时间戳 struct tm set_time; set_time.tm_year = 2024 - 1900; // 年份从1900开始算，2024年就是124 set_time.tm_mon = 4; // 月份0-11，4代表5月 set_time.tm_mday = 15; set_time.tm_hour = 14; set_time.tm_min = 30; set_time.tm_sec = 0; time_t set_timestamp = mktime(&set_time); // 转换为时间戳 // 设置RTC rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_SET_TIME, &set_timestamp); } ``` 注意： - 使用`localtime`函数时，返回的是静态内存，不可重入。在多线程环境中，可以使用`localtime_r`（如果支持）。 - 设置时间时，需要先构造`struct tm`，然后通过`mktime`转换为`time_t`。 另外，引用[4]提到了RTC Alarm组件的使用，但用户当前问题只关注时间结构体。 如果用户使用的硬件平台（如GD32）的驱动中确实定义了一个名为`rtc_timestamp_struct`的结构体，那么它可能是特定于该驱动的一个结构体。这种情况下，需要查阅该驱动的具体实现。但根据引用[1]中的描述，在RT-Thread中，驱动层最终通过`get_rtc_timestamp`函数返回一个时间戳（整数），并没有提到自定义结构体。 因此，我们建议用户使用标准的`struct tm`和`time_t`进行时间操作，这样可移植性更好。 如果用户确实需要直接操作硬件RTC的寄存器结构体（如GD32的`rtc_init_config_struct`），请参考之前关于GD32初始化的回答。 总结：在RT-Thread中，推荐使用标准C库的时间函数和RT-Thread的RTC设备控制命令来操作时间，避免直接使用硬件相关的结构体，除非有特殊需求。 相关问题： 1. RT-Thread中如何设置RTC的闹钟功能？ 2. 如何将分解时间（年、月、日等）转换为Unix时间戳？ 3. 在RT-Thread中，如何为不同的硬件平台编写RTC驱动？</think>### RTC时间戳结构体使用指南 在RT-Thread中，`rtc_timestamp_struct`是用于处理RTC时间戳的核心数据结构。以下是详细使用方法和配置示例： --- ### 1. **结构体定义与成员解析** 在RT-Thread的RTC驱动中，时间戳通常通过以下结构体处理（需根据具体驱动实现）： ```c // 常见时间戳结构体定义 (drv_rtc.c) struct rtc_time { int tm_sec; // 秒 [0,59] int tm_min; // 分 [0,59] int tm_hour; // 时 [0,23] int tm_mday; // 日 [1,31] int tm_mon; // 月 [0,11] (0=1月) int tm_year; // 年 (实际年份=1900+tm_year) int tm_wday; // 星期 [0,6] (0=周日) }; ``` --- ### 2. **核心操作函数** #### (1) 获取时间戳 通过设备控制命令获取时间： ```c #include <rtdevice.h> void get_rtc_timestamp(void) { rt_device_t rtc_dev = rt_device_find("rtc"); struct rtc_time tm; // 获取时间戳结构体 rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_GET_TIME, &tm); rt_kprintf("Time: %04d-%02d-%02d %02d:%02d:%02d\n", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec); } ``` #### (2) 设置时间戳 ```c void set_rtc_timestamp(void) { rt_device_t rtc_dev = rt_device_find("rtc"); struct rtc_time tm = { .tm_year = 124, // 2024年 (2024-1900) .tm_mon = 4, // 5月 (0-based) .tm_mday = 15, .tm_hour = 14, // 14:30:00 .tm_min = 30, .tm_sec = 0 }; // 应用时间戳 rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_SET_TIME, &tm); } ``` --- ### 3. **完整配置流程示例** ```c #include <rtthread.h> #include <rtdevice.h> int rtc_demo_init(void) { // 1. 查找RTC设备 rt_device_t rtc_dev = rt_device_find("rtc"); if (!rtc_dev) { rt_kprintf("RTC device not found!\n"); return -RT_ERROR; } // 2. 初始化RTC硬件 if (rt_device_open(rtc_dev, RT_DEVICE_FLAG_RDWR) != RT_EOK) { rt_kprintf("Failed to open RTC device\n"); return -RT_ERROR; } // 3. 设置初始时间戳 struct rtc_time init_time = { .tm_year = 124, // 2024 .tm_mon = 4, // 5月 .tm_mday = 15, .tm_hour = 14, .tm_min = 30, .tm_sec = 0 }; rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_SET_TIME, &init_time); // 4. 验证时间戳 struct rtc_time current_time; rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_GET_TIME, &current_time); rt_kprintf("RTC Set: %d-%d-%d %02d:%02d:%02d\n", current_time.tm_year + 1900, current_time.tm_mon + 1, current_time.tm_mday, current_time.tm_hour, current_time.tm_min, current_time.tm_sec); return RT_EOK; } INIT_APP_EXPORT(rtc_demo_init); // 自动初始化 ``` --- ### 4. **关键注意事项** 1. **时间格式转换**： - 年份需转换为`tm_year = 实际年份 - 1900` - 月份范围是`0-11`（0表示1月） - 使用工具函数简化转换： ```c void set_rtc_time(int year, int month, int day, int hour, int min, int sec) { struct rtc_time tm = { .tm_year = year - 1900, .tm_mon = month - 1, .tm_mday = day, .tm_hour = hour, .tm_min = min, .tm_sec = sec }; rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_SET_TIME, &tm); } ``` 2. **硬件依赖操作**： - 首次配置需初始化时钟源（LSE/LSI）[^2] - 操作前需等待寄存器同步： ```c while (rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_SYNC, RT_NULL) != RT_EOK) { rt_thread_mdelay(10); } ``` 3. **闹钟功能集成**： 结合RTC Alarm组件实现闹钟功能[^4]： ```c #include <rtc_alarm.h> void set_alarm(void) { struct rtc_time alarm_time = { ... }; rtc_alarm_set("rtc", &alarm_time, alarm_callback, RT_NULL); } ``` --- ### 5. **调试与错误处理** ```c // 检查RTC状态 rt_err_t status = rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_GET_STATUS, RT_NULL); if (status != RT_EOK) { rt_kprintf("RTC error: 0x%x\n", status); // 错误码分析: // 0x10: 时钟源未就绪 (检查LSE/LSI) // 0x20: 寄存器同步失败 // 0x30: 备份域未解锁 } ``` > **提示**：在RT-Thread中，底层驱动通过`rt_device_control`的`RT_DEVICE_CTRL_RTC_GET_TIME/SET_TIME`命令与`struct rtc_time`交互，具体实现在`drivers/drv_rtc.c`的`get_rtc_timestamp/set_rtc_timestamp`函数中[^1]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值