按键驱动加RTC

最新推荐文章于 2024-01-18 22:58:03 发布
最新推荐文章于 2024-01-18 22:58:03 发布
阅读量491 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sususuda/article/details/81071785
版权
该博客详细介绍了如何在Linux内核中实现RTC（实时时钟）DS3231的驱动程序，包括读取和设置时间、I2C通信以及中断处理。通过GPIO进行中断触发，并展示了相关的寄存器定义和中断服务例程。

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

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/i2c.h>
#include <linux/rtc.h>
#include <linux/bcd.h>
#include <linux/workqueue.h>
#include <linux/slab.h>
#include <linux/dma-mapping.h>
#include <asm/delay.h>
#include <linux/delay.h>


void __iomem* reg_gpio_base_va = 0;
#define GPIO_ADRESS_BASE         0x12140000
#define GPIO_CTRL_ADRESS_BASE    0x12040000


#define HI_IO_GPIO_ADDRESS(x)  (reg_gpio_base_va + ((x)-(GPIO_ADRESS_BASE)))
#define GPIO9_REG6       HI_IO_GPIO_ADDRESS(GPIO_ADRESS_BASE+(0x9000)+0x100)
#define I2C1_CTRL_REG6   HI_IO_GPIO_ADDRESS(GPIO_CTRL_ADRESS_BASE+0x005C) 
#define I2C1_CTRL_REG7   HI_IO_GPIO_ADDRESS(GPIO_CTRL_ADRESS_BASE+0x0060)
#define GPIO9_CTRL_REG6  HI_IO_GPIO_ADDRESS(GPIO_CTRL_ADRESS_BASE+0x0134)
#define GPIO9_IS6         HI_IO_GPIO_ADDRESS(GPIO_ADRESS_BASE+(0x9000)+0x404)
#define GPIO9_IBE6         HI_IO_GPIO_ADDRESS(GPIO_ADRESS_BASE+(0x9000)+0x408)
#define GPIO9_IEV6       HI_IO_GPIO_ADDRESS(GPIO_ADRESS_BASE+(0x9000)+0x40C)
#define GPIO9_IC6        HI_IO_GPIO_ADDRESS(GPIO_ADRESS_BASE+(0x9000)+0x41C)
#define GPIO9_IE6        HI_IO_GPIO_ADDRESS(GPIO_ADRESS_BASE+(0x9000)+0x410)
#define GPIO9_DIR6         HI_IO_GPIO_ADDRESS(GPIO_ADRESS_BASE+(0x9000)+0x400)
#define GPIO_SET(g,r)           ((*(volatile unsigned int *)g) |=  (1<<(r))) 
#define GPIO_RST(g,r)           ((*(volatile unsigned int *)g) &= ~(1<<(r)))
#define  GPIO_WRITE_REG(Addr, Value)     ((*(volatile unsigned int *)(Addr))=(Value))
#define  GPIO_READ_REG(Addr)             (*(volatile unsigned int *)(Addr))


#define MODULE_VERSION_STRING    "RTC-DS3231"
#define DS3232_DRIVER_VERSION    "v1.0.0"

#define DS3231_REG_SECONDS    0x00
#define DS3231_REG_MINUTES    0x01
#define DS3231_REG_HOURS    0x02
#define DS3231_REG_AMPM        0x02
#define DS3231_REG_DAY        0x03
#define DS3231_REG_DATE        0x04
#define DS3231_REG_MONTH    0x05
#define DS3231_REG_CENTURY    0x05
#define DS3231_REG_YEAR        0x06
#define DS3231_REG_ALARM1         0x07    /* Alarm 1 BASE */
#define DS3231_REG_ALARM2         0x0B    /* Alarm 2 BASE */
#define DS3231_REG_CR        0x0E    /* Control register */
#define DS3231_REG_CR_nEOSC        0x80
#define DS3231_REG_CR_INTCN        0x04
#define DS3231_REG_CR_A2IE        0x02
#define DS3231_REG_CR_A1IE        0x01

#define DS3231_REG_SR    0x0F    /* control/status register */
#define DS3231_REG_SR_OSF   0x80
#define DS3231_REG_SR_BSY   0x04
#define DS3231_REG_SR_A2F   0x02
#define DS3231_REG_SR_A1F   0x01

#define DEVICE_NAME            "ds3231rtc"
#define I2C_ADDR_DS3231        0xD0
#ifdef DS3231_DEBUG
#define HI_MSG(x...) \
do { \
    printk("%s->%d: ", __FUNCTION__, __LINE__); \
    printk(x); \
    printk("\n"); \
} while (0)    
#else
#define HI_MSG(args...) do { } while (0)
#endif

#define HI_ERR(x...) \
do { \
    printk(KERN_ALERT "%s->%d: ", __FUNCTION__, __LINE__); \
    printk(KERN_ALERT x); \
    printk(KERN_ALERT "\n"); \
} while (0)

#ifdef DS3231_DEBUG
static void display_rtc_time_in_bcd(struct rtc_time *rtime)
{
    printk("tm_sec: %u\n", rtime->tm_sec);
    printk("tm_min: %u\n", rtime->tm_min);
    printk("tm_hour: %u\n", rtime->tm_hour);
    printk("tm_mday: %u\n", rtime->tm_mday);
    printk("tm_mon: %u\n", rtime->tm_mon);
    printk("tm_year: %u\n", rtime->tm_year);
    printk("tm_wday: %u\n", rtime->tm_wday);
    printk("tm_yday: %u\n", rtime->tm_yday);
    printk("tm_isdst: %u\n", rtime->tm_isdst);
}
#endif
struct rtc_time timess;
struct i2c_client *rtc_client;
struct rtc_device *rtc;
struct device *devicess;
int temp_flag=0;

extern int hi_i2c_dma_read(const struct i2c_client *client, unsigned int data_addr,
        unsigned int reg_addr, unsigned int reg_addr_num,
        unsigned int length);
extern int hi_i2c_dma_write(const struct i2c_client *client, unsigned int data_addr,
        unsigned int reg_addr, unsigned int reg_addr_num,
        unsigned int length);
const struct i2c_device_id ds3231_id[]=
{

{"ds3231rtc",2},
{}
};

static struct i2c_board_info i2c_ds3231rtc=
{
//参数一 名称
//参数二 从设备地址
I2C_BOARD_INFO("ds3231rtc", (I2C_ADDR_DS3231>>1)),
};
static void display_rtc_time_in_bcd(struct rtc_time *rtime)
{
    printk("tm_sec: %u\n", rtime->tm_sec);
    printk("tm_min: %u\n", rtime->tm_min);
    printk("tm_hour: %u\n", rtime->tm_hour);
    printk("tm_mday: %u\n", rtime->tm_mday);
    printk("tm_mon: %u\n", rtime->tm_mon);
    printk("tm_year: %u\n", rtime->tm_year);
    printk("tm_wday: %u\n", rtime->tm_wday);
//    printk("tm_yday: %u\n", rtime->tm_yday);
//    printk("tm_isdst: %u\n", rtime->tm_isdst);
}

static int i2cdev_read(char *buf, unsigned int count,
        unsigned int reg_addr_num, unsigned int data_byte_num)
{
    int ret;
    unsigned char tmp_buf0[4];
    unsigned char tmp_buf1[4];
    struct i2c_msg msg[2];
    int idx = 0;
    struct i2c_client * client;
    client=rtc_client;
    msg[0].addr = (I2C_ADDR_DS3231>>1);
    msg[0].flags = client->flags & I2C_M_TEN;
    msg[0].len = reg_addr_num;
    msg[0].buf = tmp_buf0;
    if(reg_addr_num == 1)
    {
        tmp_buf0[idx++] = buf[0]&0xff;
    }
    else
    {
        tmp_buf0[idx++] = (buf[0] >> 8)&0xff;
        tmp_buf0[idx++] = buf[0]&0xff;
    }
    msg[1].addr = (I2C_ADDR_DS3231>>1);
    msg[1].flags = client->flags & I2C_M_TEN;
    msg[1].flags |= I2C_M_RD;
    msg[1].len = data_byte_num;
    msg[1].buf = tmp_buf1;
    ret = i2c_transfer(client->adapter, msg, 2);
    if (ret == 2)
    {
        if (data_byte_num == 2)
        {
            buf[1] = tmp_buf1[1];
            buf[0] = tmp_buf1[0];
        }
        else
        {
            buf[0] = tmp_buf1[0];
        }
    }
    else
    {
        return 0;
    }
    return 1;
}
static int ds3231_i2c_readbyte(struct i2c_client *client, unsigned char reg_addr)
{
    int ret = 0;
    unsigned char buf[2];

    buf[0] = reg_addr;
    ret = i2cdev_read(buf, 1, 1, 1);
    if (ret < 0)
    {
        dev_err(&client->dev, "ds3231_i2c_readbyte fail...\n");
        return ret;
    }
    
    return buf[0];
}
static int ds3231_i2c_writebyte(struct i2c_client *client,unsigned char reg_addr,
    unsigned char value)
{
    int ret = 0;
    unsigned char buf[2];

    buf[0] = reg_addr;
    buf[1] = value;

    ret = i2c_master_send(client, buf, 2);
    return ret;
}

static int ds3231_i2c_dma_read(struct i2c_client *client, unsigned char reg_addr, 
        unsigned char len, unsigned char *buffer)
    {
        int ret;
        dma_addr_t dma_handle;
        unsigned char *p;
        printk("enter dma_read...................\n");
        p = dma_alloc_coherent(NULL, len, &dma_handle, GFP_KERNEL);
        if(p == NULL)
        {
            printk("dma_alloc_coherent fail\n");
            return -1;
        }
        ret = hi_i2c_dma_read(client, dma_handle, reg_addr, 1, len);
        if(ret)
            printk("dma_write fail:%d.\n", ret);
    
        memcpy(buffer, p, len);
        dma_free_coherent(NULL, len, p, dma_handle);
        return 0;
    }
static int ds3231_i2c_dma_write(struct i2c_client *client,unsigned char reg_addr,
            unsigned char len,unsigned char *buffer)
    {
            int ret;
            dma_addr_t dma_handle;
            unsigned char *p;
        
            p = dma_alloc_coherent(NULL, len, &dma_handle, GFP_KERNEL);
            if(p == NULL)
            {
                printk("dma_alloc_coherent fail\n");
                return -1;
            }
            memcpy(p, buffer, len);
            
            ret = hi_i2c_dma_write(client, dma_handle, reg_addr, 1, len);
            if(ret)
                printk("dma_write fail:%d.\n", ret);
        
            dma_free_coherent(NULL, len, p, dma_handle);
            return 0;
    }
static int ds3231_read_time(struct device *dev,struct rtc_time *time)
    {
        struct i2c_client *client = rtc_client;
        int ret;
        u8 buf[7];
        unsigned int year, month, day, hour, minute, second;
        unsigned int week, twelve_hr, am_pm;
        unsigned int century, add_century = 0;
    
        ret = ds3231_i2c_dma_read(client, DS3231_REG_SECONDS, 7, buf);
    
        if (ret < 0) {
            dev_warn(&client->dev, "ds3231_i2c_dma_read read time error!ret = %d\n", ret);
            return ret;
        }
    
        second = buf[0];
        minute = buf[1];
        hour = buf[2];
        week = buf[3];
        day = buf[4];
        month = buf[5];
        year = buf[6];
                                
        /* Extract additional information for AM/PM and century */
        twelve_hr = hour & 0x40;
        am_pm = hour & 0x20;
        century = month & 0x80;
#ifdef DS3231_DEBUG
    {
    int i;
    printk("read from rtc-ds3231m: ");
    for (i = 0; i < 7; i++) {
        printk("0x%02x ", buf[i]);
    }
    printk("\n");
                                        
    }
#endif
    /* Write to rtc_time structure */
                                
    time->tm_sec = bcd2bin(second);
    time->tm_min = bcd2bin(minute);
    if (twelve_hr) {
    /* Convert to 24 hr */
    if (am_pm)
    time->tm_hour = bcd2bin(hour & 0x1F) + 12;
    else
    time->tm_hour = bcd2bin(hour & 0x1F);
    } else {
    time->tm_hour = bcd2bin(hour);
    }
                                
    /* Day of the week in linux range is 0~6 while 1~7 in RTC chip */
    time->tm_wday = bcd2bin(week) - 1;
    time->tm_mday = bcd2bin(day);
    /* linux tm_mon range:0~11, while month range is 1~12 in RTC chip */
    time->tm_mon = bcd2bin(month & 0x7F) - 1;
    if (century)
    add_century = 100;
                                
    time->tm_year = bcd2bin(year) + add_century;
                                
    ret = rtc_valid_tm(time); 
    if (ret < 0) {
    dev_err(&client->dev, "rtc_valid_tm return ret: %d\n", ret);
    }

    timess.tm_sec=time->tm_sec;
    timess.tm_hour=time->tm_hour;
    timess.tm_min=time->tm_min;
    timess.tm_mon=(time->tm_mon) +1;
    timess.tm_mday=time->tm_mday;
    timess.tm_wday=time->tm_wday;
    timess.tm_year=(time->tm_year)+1900;

    return ret;
}
static int ds3231_set_time(struct device *dev, struct rtc_time *time)
{
    struct i2c_client *client = to_i2c_client(dev);
    u8 buf[7];
    int ret;
    /* Extract time from rtc_time and load into ds3231*/

    buf[0] = bin2bcd(time->tm_sec);
    buf[1] = bin2bcd(time->tm_min);
    buf[2] = bin2bcd(time->tm_hour);
    /* Day of the week in linux range is 0~6 while 1~7 in RTC chip */
    buf[3] = bin2bcd(time->tm_wday + 1);
    buf[4] = bin2bcd(time->tm_mday); /* Date */
    /* linux tm_mon range:0~11, while month range is 1~12 in RTC chip */
    buf[5] = bin2bcd(time->tm_mon + 1);
    if (time->tm_year >= 100) {
        buf[5] |= 0x80;
        buf[6] = bin2bcd(time->tm_year - 100);
    }
    else 
    {
        buf[6] = bin2bcd(time->tm_year);
    }

#ifdef DS3231_DEBUG
    {
        int i = 0;
        display_rtc_time_in_bcd(time);
        printk("write buffer: ");
        for (i = 0; i < 7; i++) {
            printk("0x%02x ", buf[i]);
        }
        printk("\n");
    }
#endif
    ret = ds3231_i2c_dma_write(client,
                          DS3231_REG_SECONDS, 7, buf);
    
    if (ret < 0) {
        dev_err(&client->dev, "ds3231_i2c_dma_write set time failed, ret: %d\n", ret);
    } else {
        /* take some sleep to fix bug read immendiately after set */
        udelay(500);
    }
    return ret;
}
static int ds3231_check_rtc_status(struct i2c_client *client)
{
    int ret = 0;
    int control, stat;

    stat = ds3231_i2c_readbyte(client, DS3231_REG_SR);
    if (stat < 0) {
        dev_err(&client->dev, "ds3231_i2c_readbyte failed!stat = 0x%08x\n", stat);
        return stat;
    }

    if (stat & DS3231_REG_SR_OSF)
        dev_warn(&client->dev,
                "oscillator discontinuity flagged, "
                "time unreliable\n");

    stat &= ~(DS3231_REG_SR_OSF | DS3231_REG_SR_A1F | DS3231_REG_SR_A2F);

    ret = ds3231_i2c_writebyte(client, DS3231_REG_SR, stat);
    if (ret < 0) {
        dev_warn(&client->dev, "ds3231_i2c_writebyte error!\n");
        return ret;
    }

    /* If the alarm is pending, clear it before requesting
     * the interrupt, so an interrupt event isn't reported
     * before everything is initialized.
     */

    control = ds3231_i2c_readbyte(client, DS3231_REG_CR);
    if (control < 0) {
        dev_warn(&client->dev, "ds3231_i2c_readbyte read control error!control = 0x%08x\n", control);
        return control;
    }

    control &= ~(DS3231_REG_CR_A1IE | DS3231_REG_CR_A2IE);
    control |= DS3231_REG_CR_INTCN;

    ret = ds3231_i2c_writebyte(client, DS3231_REG_CR, control);
    if (ret < 0) {
        dev_warn(&client->dev, "ds3231_i2c_writebyte write control error!ret = 0x%08x\n", ret);
        return control;
    }
    return ret;
}
void read_ds3231(void)
{
            
        struct i2c_client *client = rtc_client;
        int ret;
        u8 buf[7];
        struct rtc_time rtc_tm ;
        
        unsigned int year, month, day, hour, minute, second;
        unsigned int week, twelve_hr, am_pm;
        unsigned int century, add_century = 0;
        printk("enter ds3231_read\n");

        ret = ds3231_i2c_dma_read(client, DS3231_REG_SECONDS, 7, buf);

        second = buf[0];
        minute = buf[1];
        hour = buf[2];
        week = buf[3];
        day = buf[4];
        month = buf[5];
        year = buf[6];
                                
        /* Extract additional information for AM/PM and century */
        twelve_hr = hour & 0x40;
        am_pm = hour & 0x20;
        century = month & 0x80;
        printk("asdasdasadasdasd\n");
        
        /* Write to rtc_time structure */                        
        rtc_tm.tm_sec = bcd2bin(second);
        rtc_tm.tm_min = bcd2bin(minute);
        if (twelve_hr) {
        /* Convert to 24 hr */
        if (am_pm)
        rtc_tm.tm_hour = bcd2bin(hour & 0x1F) + 12;
        else
        rtc_tm.tm_hour = bcd2bin(hour & 0x1F);
        } else {
        rtc_tm.tm_hour = bcd2bin(hour);
        }
                                    
        /* Day of the week in linux range is 0~6 while 1~7 in RTC chip */
        rtc_tm.tm_wday = bcd2bin(week) - 1;
        rtc_tm.tm_mday = bcd2bin(day);
        /* linux tm_mon range:0~11, while month range is 1~12 in RTC chip */
        rtc_tm.tm_mon = bcd2bin(month & 0x7F);
        if (century)
        add_century = 2000;
                                    
        rtc_tm.tm_year = bcd2bin(year) + add_century;
                                    
        ret = rtc_valid_tm(&rtc_tm); 
        if (ret < 0) {
        dev_err(&client->dev, "rtc_valid_tm return ret: %d\n", ret);
        }
        display_rtc_time_in_bcd(&rtc_tm);
    
}

static const struct rtc_class_ops ds3231_rtc_ops = {
    .read_time = ds3231_read_time,
    .set_time = ds3231_set_time,
//    .read_alarm = ds3231_read_alarm,
//    .set_alarm = ds3231_set_alarm,
//    .alarm_irq_enable = ds3231_alarm_irq_enable,
};
int ds3231rtc_probe(struct i2c_client *client,const struct i2c_device_id *id)
{        
        int ret;
        printk("enter ds3231_probe\n");
        ret = ds3231_check_rtc_status(client);
        if (ret < 0) {
        dev_err(&client->dev, "ds3231_check_rtc_status failed! ret = %d\n", ret);
        return ret;
        }
        rtc = devm_rtc_device_register(&client->dev, client->name,
                                  &ds3231_rtc_ops, THIS_MODULE);
        read_ds3231();
        return 0;
}
int ds3231rtc_remove(struct i2c_client *client)
{


        return 0; 
}


struct i2c_driver  ds3231_driver=
{
        .driver =
        {
        .name="ds3231rtc",
        .owner=THIS_MODULE,
                
        },
        .probe =ds3231rtc_probe,
        .remove=ds3231rtc_remove,
        /*i2c match 会使用到*/
        .id_table=ds3231_id,
};

irqreturn_t ds3231_isr(int irq,void *dev_id)
{    
    int ret;
    int times=0;

    printk("occur up key press!\n");

    GPIO_READ:
    ret=GPIO_READ_REG(GPIO9_REG6);
    if(ret==0)
    {
    times++;
    mdelay(100);
    goto GPIO_READ;
    }
    printk("times-> %d ms\n",(times));

    display_rtc_time_in_bcd(&timess);
    return IRQ_HANDLED;
}


int __init ds3231rtc_init(void)
{        
        int ret;
        struct i2c_adapter* i2c_adap;
        reg_gpio_base_va = ioremap(GPIO_ADRESS_BASE,0x100);
    //    GPIO_WRITE_REG(I2C1_CTRL_REG6, 1);//设置GPIO1_6复用
    //    GPIO_WRITE_REG(I2C1_CTRL_REG7, 1);//设置GPIO1_7复用
        GPIO_WRITE_REG(GPIO9_CTRL_REG6, 0);//设置GPIO1_7复用
        GPIO_RST(GPIO9_DIR6, 6);//按键为输出
        /*配置中断*/
        GPIO_RST(GPIO9_IS6, 6);
        GPIO_RST(GPIO9_IEV6,6);
        GPIO_RST(GPIO9_IBE6,6);
        GPIO_SET(GPIO9_IC6, 6);
        GPIO_SET(GPIO9_IE6, 6);


        /*注册中断*/
        ret=request_irq(76,ds3231_isr,IRQF_SHARED,"interrupt_demo",(void*)0x01);
        if(ret==0)
        {
        printk("success\n");
        }
        else
        {    
        printk("%d",ret);
        }

        i2c_adap   = i2c_get_adapter(2);//I2C2
        rtc_client = i2c_new_device(i2c_adap, &i2c_ds3231rtc);
        i2c_put_adapter(i2c_adap);
        i2c_add_driver(&ds3231_driver);
    
            
        return 0;
}

void __exit ds3231rtc_exit(void)
{
        iounmap(reg_gpio_base_va);
        free_irq(76,(void *)0x01);
        i2c_unregister_device(rtc_client);
        i2c_del_driver(&ds3231_driver);
        printk("ds3231 driver unregistered\n");
}
module_init(ds3231rtc_init);
module_exit(ds3231rtc_exit);
MODULE_LICENSE("GPL");


 

温暖SD
关注
【Linux (OrangePi) 】 DS3231M配置为硬件时钟
冫Michael的博客
04-22 819
是:Enable or disable network time synchronization（是否开启网络时间同步）默认是打开的，是:Control whether RTC is in local time, 默认是关闭的,我们把它打开。没错，又变回去了，我们得执行一次下面指令才能把DM3221的时间同步过来(注意参数变成。执行以下命令:(把当前正确的时间写入DS3231M, 然后再读出来测试下)当然，系统自带的断电就不会继续计时了，所以时间才会不准确，除非连上网络。新增以下2行，达到开机启动的目的。
ds3231
sususuda的博客
07-16 1834
#include &lt;linux/kernel.h&gt; #include &lt;linux/module.h&gt; #include &lt;linux/interrupt.h&gt; #include &lt;linux/i2c.h&gt; #include &lt;linux/rtc.h&gt; #include &lt;linux/bcd.h&gt; #include &lt;l...
linux下ds3231应用程序,DS3231.h和DS3231.C单片机mcu时钟芯片驱动下载
weixin_39547392的博客
05-04 335
/******************************************************************************* 名称：D3231.c* 描述：D3231模块驱动的实现文件* 编写：* 日期：2010.07.23********************************************************...
DS3231+12864 0.96oled 51单片机程序
11-16
也是在网上看到的DS3231代码，使用的0.96OLED【屏幕】，不过代码仅仅是可以正常使用，调节按键，还没来得及修改，IIC驱动还有OLED驱动都在相应的H文件里面；
基于DS3231时钟模块的stm32 Hal库程序，源码
黑猫警长的博客
11-18 3435
关于DS3231模块我在我的博客基于DS3231时钟模块的stm32 程序，源码中有介绍 ，大家可以自己看下。我这篇直接讲HAL的代码。 一、配置IO /** /** ****************************************************************************** * @file bsp_i2c_ds3231.h * @author 兲涳 * @version V1.0 * @date 2020-11-18
RTC-timer.zip_RTC_STM32 oled_STM32F103_oled 按键_stm32f103 rtc
09-23
总结来说，这个项目展示了如何在STM32F103微控制器上构建一个完整的RTC系统，包括RTC模块的配置、OLED显示屏的驱动、按键的处理以及可能的温度测量功能。这样的系统对于开发需要时间显示和用户交互的嵌入式应用非常...
STM32F103C8T6按键调整参数断电保护，温湿度，实时时钟rtc，OLED，定时器
04-30
在这个项目中，开发者利用STM32F103C8T6进行了一系列功能实现，包括按键调整参数、断电保护、温湿度监测、实时时钟（RTC）以及OLED显示屏的应用。 首先，关于“STM32F103C8T6按键调整参数”，这通常涉及到用户交互...
I2C接口RTC实时时钟pcf8563读写Verilog驱动源码Quartus工程文件.zip
03-14
I2C接口RTC实时时钟pcf8563读写Verilog驱动源码Quartus工程文件,FPGA型号Cyclone4E系列中的EP4CE10F17C8，Quartus版本18.0。 module rtc( //system clock input sys_clk , // 系统时钟 input sys_rst_n , // ...
LM3S单片机扩展：按键、数码管与RTC应用教程
这款芯片的强大之处在于能够驱动多达8位共阴数码管或高达64个独立LED和64个按键，支持多种显示模式，如数据译码、循环移位段寻址，甚至可以检测58个功能键的连击次数，大大简化了硬件设计。此外，它还允许用户自定义...
STM32H743实现RTC实时时钟【支持STM32H7系列单片机_HAL库驱动】.zip
01-30
STM32H743的RTC功能还可以与HAL库中的其他模块结合使用，如GPIO、EXTI（外部中断）等，实现更复杂的应用场景，如通过外部按键触发RTC时间的查看或设置。 综上所述，这个项目为STM32H743的RTC功能提供了完整的HAL库...
基于STM32F103驱动DS3231完整代码，已通过串口调试
09-11
资源为一个完整的基于STM32F103驱动DS3231工程，使用了硬件IIC与DS3231通信，工程已经通过了串口二测试，直接使用Keil5 MDK打开即可，方便移植。
DS3231高精度时钟驱动及数码管显示时间
06-10
DS3231时钟显示，在4位时钟数码管上显示小时和分钟 地址分配：时钟为4位共阴时钟数码管，74HC573驱动，接P0口（须接上接电阻） P20：74HC573片选，P21：小时十位位选；P22：小时个位位选；P23：时钟小数点位选；P24：分钟十位位选；P25：分钟个位位选。 P10：SCL；P11：SDA；P12：key1;P13:key2; P14:key3。 功能说明： key1：用来切换4位，切换到哪位，哪位就闪烁，此时可以用key2对闪烁位进行修改，修改好按key3键进行确认，完成时间的修改。 特点： DS3232SN计时准确，key2依赖于key1,key3依赖于key2，前者变化是后者变化的基础。即若不处于修改状态，是没有办法修改的， 若key2没有执行修改，key3是不能进行确认的。这样可以保证误操作。
ds3231程序
09-18
高精度时钟芯片带补偿ds3231的C语言程序，模块化编程，即添即用
STM32F030F4-IIC+DS3231时钟芯片例程+中文资料
03-09
CUBEMX构建的STM32F030F4的HAL库例子。采用硬件IIC读写DS3231时钟芯片。封装了DS3231功能的函数，直接调用。附带中英文资料文档。
DS3231SN完整代码
08-05
DS3231SN完整代码
【STM32】DS3231硬件I2C读写，基于HAL库
最新发布
我的博客
01-18 3220
DS3231，除了I2C通信引脚和电源引脚，剩余引脚并未引出，如下图所示。笔者的单片机为STM32F103CBT6，使用I2C2因此接线如下。
[嵌入式开发模块]DS3231时钟芯片 驱动程序
热门推荐
夏日白云的boke
05-14 1万+
此为本人写的DS3231时钟芯片的驱动程序
矩阵键盘修改时间c语言,通过矩阵键盘修改STM32F103的RTC时间
weixin_39593961的博客
05-25 1257
void set_time() //设置时间{unsigned char n=0;int m;for(;;){OLED_Clear(0);OLED_Display_Flont(0+16*2,0,flont_shijian[0]);OLED_Display_Flont(0+16*3,0,flont_shijian[1]);OLED_Display_Flont(0+16*4,0,flont_shiji...
UCOSIII实战-----RTC+DHT11+按键+LCD显示
a568713197的博客
11-08 9696
前言  学习UCOSIII也已经有俩周了，跟着原子哥的教程以及官方的手册把所有的知识点大概都看了一遍，但是纸上得来终觉浅，作为嵌入式的学习者，实战是最最重要的环节，所以今天花了大概俩个小时左右做了一个小的实战项目，也用到了不少的知识，也感觉对知识起到了不错的巩固作用。这篇博客就记录一下这个小项目，也记录一下在做的过程中遇到的一些问题。 项目需求  1、使用DHT11读取温湿度值  2、RTC时钟 ...
STM32实时时钟RTC与彩屏及按键交互
根据给定的文件信息，可以看出本项目的知识点主要涉及stm32单片机、实时时钟(RTC)模块、串口通信、彩色显示屏以及按键检测功能。现在将分别对这些知识点进行详细阐述。 1. STM32单片机： STM32是STMicroelectronics...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值