NUCLEO-F411RE RT-Thread 体验 (10) - GCC环境 AT24CXX的使用

已于 2023-06-23 16:51:07 修改
阅读量288 收藏 1
点赞数 2
分类专栏： RT-Thread 文章标签： stm32 单片机 嵌入式硬件
于 2023-06-23 16:49:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43932857/article/details/131351956
版权

NUCLEO-F411RE RT-Thread 体验 (10) - GCC环境 AT24CXX的使用

1、AT24CXX的移植

软件包下载

在reconfigure.h添加at24cxx的定义

在这里插入图片描述

Makefile里添加编译

在这里插入图片描述
这里我放在了User目录下，里面所有的.c文件都会被编译进去。

2、测试

封装一个结构体，将结构体填充后，写到eeprom中，然后从eeprom读出来，看数据是否一致。
在这里插入图片描述
结构体大小为120K，最小的at24c01 128K字节，也能读写。
at24C02测试如下：
在这里插入图片描述
at24C256测试如下：
在这里插入图片描述

3、修改后的代码

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2019-04-13     XiaojieFan   the first version
 * 2019-12-04     RenMing      ADD PAGE WRITE and input address can be selected
 * 2022-10-11     GuangweiRen  Delay 2ms after writing one byte
 */
#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

#include <string.h>
#include <stdlib.h>

#define DBG_ENABLE
#define DBG_SECTION_NAME "at24xx"
#define DBG_LEVEL DBG_LOG
#define DBG_COLOR

#include <rtdbg.h>

#include "at24cxx.h"

#ifdef PKG_USING_AT24CXX
#define AT24CXX_ADDR (0xA0 >> 1)                      //A0 A1 A2 connect GND

#if (EE_TYPE == AT24C01)
    #define AT24CXX_PAGE_BYTE               8
    #define AT24CXX_MAX_MEM_ADDRESS         128
#elif (EE_TYPE == AT24C02)
    #define AT24CXX_PAGE_BYTE               8
    #define AT24CXX_MAX_MEM_ADDRESS         256
#elif (EE_TYPE == AT24C04)
    #define AT24CXX_PAGE_BYTE               16
    #define AT24CXX_MAX_MEM_ADDRESS         512
#elif (EE_TYPE == AT24C08)
    #define AT24CXX_PAGE_BYTE               16
    #define AT24CXX_MAX_MEM_ADDRESS         1024
#elif (EE_TYPE == AT24C16)
    #define AT24CXX_PAGE_BYTE               16
    #define AT24CXX_MAX_MEM_ADDRESS         2048
#elif (EE_TYPE == AT24C32)
    #define AT24CXX_PAGE_BYTE               32
    #define AT24CXX_MAX_MEM_ADDRESS         4096
#elif (EE_TYPE == AT24C64)
    #define AT24CXX_PAGE_BYTE               32
    #define AT24CXX_MAX_MEM_ADDRESS         8192
#elif (EE_TYPE == AT24C128)
    #define AT24CXX_PAGE_BYTE               64
    #define AT24CXX_MAX_MEM_ADDRESS         16384
#elif (EE_TYPE == AT24C256)
    #define AT24CXX_PAGE_BYTE               64
    #define AT24CXX_MAX_MEM_ADDRESS         32768
#elif (EE_TYPE == AT24C512)
    #define AT24CXX_PAGE_BYTE               128
    #define AT24CXX_MAX_MEM_ADDRESS         65536
#endif

static rt_err_t read_regs(at24cxx_device_t dev, rt_uint8_t len, rt_uint8_t *buf)
{
    struct rt_i2c_msg msgs;

    msgs.addr = AT24CXX_ADDR;
    msgs.flags = RT_I2C_RD;
    msgs.buf = buf;
    msgs.len = len;

    if (rt_i2c_transfer(dev->i2c, &msgs, 1) == 1)
    {
        return RT_EOK;
    }
    else
    {
        return -RT_ERROR;
    }
}
uint8_t at24cxx_read_one_byte(at24cxx_device_t dev, uint16_t readAddr)
{
    rt_uint8_t buf[2];
    rt_uint8_t temp;
#if (EE_TYPE > AT24C16)
    buf[0] = (uint8_t)(readAddr>>8);
    buf[1] = (uint8_t)readAddr;
    if (rt_i2c_master_send(dev->i2c, AT24CXX_ADDR, 0, buf, 2) == 0)
#else
    buf[0] = readAddr;
    if (rt_i2c_master_send(dev->i2c, AT24CXX_ADDR, 0, buf, 1) == 0)
#endif
    {
        return RT_ERROR;
    }
    read_regs(dev, 1, &temp);
    return temp;
}

rt_err_t at24cxx_write_one_byte(at24cxx_device_t dev, uint16_t writeAddr, uint8_t dataToWrite)
{
    rt_uint8_t buf[3];
#if (EE_TYPE > AT24C16)
    buf[0] = (uint8_t)(writeAddr>>8);
    buf[1] = (uint8_t)writeAddr;
    buf[2] = dataToWrite;
    if (rt_i2c_master_send(dev->i2c, AT24CXX_ADDR, 0, buf, 3) == 3)
#else
    buf[0] = writeAddr; //cmd
    buf[1] = dataToWrite;
    //buf[2] = data[1];


    if (rt_i2c_master_send(dev->i2c, AT24CXX_ADDR, 0, buf, 2) == 2)
#endif
        return RT_EOK;
    else
        return -RT_ERROR;

}

rt_err_t at24cxx_read_page(at24cxx_device_t dev, uint32_t readAddr, uint8_t *pBuffer, uint16_t numToRead)
{
    struct rt_i2c_msg msgs[2];
    uint8_t AddrBuf[2];

    msgs[0].addr = AT24CXX_ADDR;
    msgs[0].flags = RT_I2C_WR ;

#if (EE_TYPE > AT24C16)
    AddrBuf[0] = readAddr >> 8;
    AddrBuf[1] = readAddr;
    msgs[0].buf = AddrBuf;
    msgs[0].len = 2;
#else
    AddrBuf[0] = readAddr;
    msgs[0].buf = AddrBuf;
    msgs[0].len = 1;
#endif

    msgs[1].addr = AT24CXX_ADDR ;
    msgs[1].flags = RT_I2C_RD;
    msgs[1].buf = pBuffer;
    msgs[1].len = numToRead;

    if(rt_i2c_transfer(dev->i2c, msgs, 2) == 0)
    {
        return RT_ERROR;
    }

    return RT_EOK;
}

rt_err_t at24cxx_write_page(at24cxx_device_t dev, uint32_t wirteAddr, uint8_t *pBuffer, uint16_t numToWrite)
{
    struct rt_i2c_msg msgs[2];
    uint8_t AddrBuf[2];

    msgs[0].addr = AT24CXX_ADDR ;
    msgs[0].flags = RT_I2C_WR ;

#if (EE_TYPE > AT24C16)
    AddrBuf[0] = wirteAddr >> 8;
    AddrBuf[1] = wirteAddr;
    msgs[0].buf = AddrBuf;
    msgs[0].len = 2;
#else
    AddrBuf[0] = wirteAddr;
    msgs[0].buf = AddrBuf;
    msgs[0].len = 1;
#endif

    msgs[1].addr = AT24CXX_ADDR;
    msgs[1].flags = RT_I2C_WR | RT_I2C_NO_START;
    msgs[1].buf = pBuffer;
    msgs[1].len = numToWrite;

    if(rt_i2c_transfer(dev->i2c, msgs, 2) <= 0)
    {
        return RT_ERROR;
    }

    return RT_EOK;
}

rt_err_t at24cxx_check(at24cxx_device_t dev)
{
    uint8_t temp;
    RT_ASSERT(dev);

    temp = at24cxx_read_one_byte(dev, AT24CXX_MAX_MEM_ADDRESS - 1);
    if (temp == 0x55) return RT_EOK;
    else
    {
        at24cxx_write_one_byte(dev, AT24CXX_MAX_MEM_ADDRESS - 1, 0x55);
        rt_thread_mdelay(EE_TWR);                 // wait 5ms befor next operation
        temp = at24cxx_read_one_byte(dev, AT24CXX_MAX_MEM_ADDRESS - 1);
        if (temp == 0x55) return RT_EOK;
    }
    return RT_ERROR;
}

/**
 * This function read the specific numbers of data to the specific position
 *
 * @param bus the name of at24cxx device
 * @param ReadAddr the start position to read
 * @param pBuffer  the read data store position
 * @param NumToRead
 * @return RT_EOK  write ok.
 */
rt_err_t at24cxx_read(at24cxx_device_t dev, uint32_t ReadAddr, uint8_t *pBuffer, uint16_t NumToRead)
{
    rt_err_t result;
    RT_ASSERT(dev);

    if(ReadAddr + NumToRead > AT24CXX_MAX_MEM_ADDRESS)
    {
        return RT_ERROR;
    }

    result = rt_mutex_take(dev->lock, RT_WAITING_FOREVER);
    if (result == RT_EOK)
    {
        while (NumToRead)
        {
            *pBuffer++ = at24cxx_read_one_byte(dev, ReadAddr++);
            NumToRead--;
        }
    }
    else
    {
        LOG_E("The at24cxx could not respond  at this time. Please try again");
    }
    rt_mutex_release(dev->lock);

    return RT_EOK;
}

/**
 * This function read the specific numbers of data to the specific position
 *
 * @param bus the name of at24cxx device
 * @param ReadAddr the start position to read
 * @param pBuffer  the read data store position
 * @param NumToRead
 * @return RT_EOK  write ok.
 */
rt_err_t at24cxx_page_read(at24cxx_device_t dev, uint32_t ReadAddr, uint8_t *pBuffer, uint16_t NumToRead)
{
    rt_err_t result = RT_EOK;
    uint16_t pageReadSize = AT24CXX_PAGE_BYTE - ReadAddr % AT24CXX_PAGE_BYTE;

    RT_ASSERT(dev);

    if(ReadAddr + NumToRead > AT24CXX_MAX_MEM_ADDRESS)
    {
        return RT_ERROR;
    }

    result = rt_mutex_take(dev->lock, RT_WAITING_FOREVER);
    if(result == RT_EOK)
    {
        while (NumToRead)
        {
            if(NumToRead > pageReadSize)
            {
                if(at24cxx_read_page(dev, ReadAddr, pBuffer, pageReadSize))
                {
                    result = RT_ERROR;
                }

                ReadAddr += pageReadSize;
                pBuffer += pageReadSize;
                NumToRead -= pageReadSize;
                pageReadSize = AT24CXX_PAGE_BYTE;
            }
            else
            {
                if(at24cxx_read_page(dev, ReadAddr, pBuffer, NumToRead))
                {
                    result = RT_ERROR;
                }
                NumToRead = 0;
            }
        }
    }
    else
    {
        LOG_E("The at24cxx could not respond  at this time. Please try again");
    }

    rt_mutex_release(dev->lock);
    return result;
}

/**
 * This function write the specific numbers of data to the specific position
 *
 * @param bus the name of at24cxx device
 * @param WriteAddr the start position to write
 * @param pBuffer  the data need to write
 * @param NumToWrite
 * @return RT_EOK  write ok.at24cxx_device_t dev
 */
rt_err_t at24cxx_write(at24cxx_device_t dev, uint32_t WriteAddr, uint8_t *pBuffer, uint16_t NumToWrite)
{
    uint16_t i = 0;
    rt_err_t result;
    RT_ASSERT(dev);

    if(WriteAddr + NumToWrite > AT24CXX_MAX_MEM_ADDRESS)
    {
        return RT_ERROR;
    }

    result = rt_mutex_take(dev->lock, RT_WAITING_FOREVER);
    if (result == RT_EOK)
    {
        while (1) //NumToWrite--
        {
            if (at24cxx_write_one_byte(dev, WriteAddr, pBuffer[i]) == RT_EOK)
            {
                rt_thread_mdelay(2);
                WriteAddr++;
            }
            if (++i == NumToWrite)
            {
                break;
            }
            rt_thread_mdelay(EE_TWR);
        }
    }
    else
    {
        LOG_E("The at24cxx could not respond  at this time. Please try again");
    }
    rt_mutex_release(dev->lock);

    return RT_EOK;
}

/**
 * This function write the specific numbers of data to the specific position
 *
 * @param bus the name of at24cxx device
 * @param WriteAddr the start position to write
 * @param pBuffer  the data need to write
 * @param NumToWrite
 * @return RT_EOK  write ok.at24cxx_device_t dev
 */
rt_err_t at24cxx_page_write(at24cxx_device_t dev, uint32_t WriteAddr, uint8_t *pBuffer, uint16_t NumToWrite)
{
    rt_err_t result = RT_EOK;
    uint16_t pageWriteSize = AT24CXX_PAGE_BYTE - WriteAddr % AT24CXX_PAGE_BYTE;

    RT_ASSERT(dev);

    if(WriteAddr + NumToWrite > AT24CXX_MAX_MEM_ADDRESS)
    {
        return RT_ERROR;
    }

    result = rt_mutex_take(dev->lock, RT_WAITING_FOREVER);
    if(result == RT_EOK)
    {
        while (NumToWrite)
        {
            if(NumToWrite > pageWriteSize)
            {
                if(at24cxx_write_page(dev, WriteAddr, pBuffer, pageWriteSize))
                {
                    result = RT_ERROR;
                }
                rt_thread_mdelay(EE_TWR);    // wait 5ms befor next operation

                WriteAddr += pageWriteSize;
                pBuffer += pageWriteSize;
                NumToWrite -= pageWriteSize;
                pageWriteSize = AT24CXX_PAGE_BYTE;
            }
            else
            {
                if(at24cxx_write_page(dev, WriteAddr, pBuffer, NumToWrite))
                {
                    result = RT_ERROR;
                }
                rt_thread_mdelay(EE_TWR);   // wait 5ms befor next operation

                NumToWrite = 0;
            }
        }
    }
    else
    {
        LOG_E("The at24cxx could not respond  at this time. Please try again");
    }

    rt_mutex_release(dev->lock);
    return result;
}

/**
 * This function initializes at24cxx registered device driver
 *
 * @param dev the name of at24cxx device
 *
 * @return the at24cxx device.
 */
at24cxx_device_t at24cxx_init(const char *i2c_bus_name)
{
    at24cxx_device_t dev;

    RT_ASSERT(i2c_bus_name);

    dev = rt_calloc(1, sizeof(struct at24cxx_device));
    if (dev == RT_NULL)
    {
        LOG_E("Can't allocate memory for at24cxx device on '%s' ", i2c_bus_name);
        return RT_NULL;
    }

    dev->i2c = rt_i2c_bus_device_find(i2c_bus_name);
    if (dev->i2c == RT_NULL)
    {
        LOG_E("Can't find at24cxx device on '%s' ", i2c_bus_name);
        rt_free(dev);
        return RT_NULL;
    }

    dev->lock = rt_mutex_create("mutex_at24cxx", RT_IPC_FLAG_FIFO);
    if (dev->lock == RT_NULL)
    {
        LOG_E("Can't create mutex for at24cxx device on '%s' ", i2c_bus_name);
        rt_free(dev);
        return RT_NULL;
    }
    return dev;
}

/**
 * This function releases memory and deletes mutex lock
 *
 * @param dev the pointer of device driver structure
 */
void at24cxx_deinit(at24cxx_device_t dev)
{
    RT_ASSERT(dev);

    rt_mutex_delete(dev->lock);

    rt_free(dev);
}

const char *eep_type[] = 
{
    "AT24C01",
    "AT24C02",
    "AT24C04",
    "AT24C08",
    "AT24C16",
    "AT24C32",
    "AT24C64",
    "AT24C128",
    "AT24C256",
    "AT24C512",
};

system_info at_system_info = {0};

void system_info_init(void)
{
    rt_sprintf(at_system_info.version,"%s %s",__DATE__,__TIME__);
    at_system_info.sysclk = HAL_RCC_GetSysClockFreq();
    at_system_info.hclk = HAL_RCC_GetHCLKFreq();
    at_system_info.apb1_clk = HAL_RCC_GetPCLK1Freq();
    at_system_info.apb2_clk = HAL_RCC_GetPCLK2Freq();
    rt_memcpy(at_system_info.eep_type,eep_type[EE_TYPE],rt_strlen(eep_type[EE_TYPE]));
    rt_sprintf(at_system_info.rt_thread_version, "%d.%d.%d build %s %s",RT_VERSION, 
                                            RT_SUBVERSION, RT_REVISION, __DATE__, __TIME__);

    at_system_info.romsize = 512;
    at_system_info.ramsize = 128;
}

void system_info_show(system_info *p_system_info)
{
    rt_kprintf(" System Info Get EepRom: \n");
    rt_kprintf(" System Version     : %s\n",p_system_info->version);
    rt_kprintf(" Eeprom Type        : %s\n",p_system_info->eep_type);
    rt_kprintf(" System Clock       : %ld\r\n",p_system_info->sysclk);
    rt_kprintf(" AHB Clock          : %ld\r\n",p_system_info->hclk);
    rt_kprintf(" APB1 Clock         : %ld\r\n",p_system_info->apb1_clk);
    rt_kprintf(" APB2 Clock         : %ld\r\n",p_system_info->apb2_clk);
    rt_kprintf(" RT-Thread Version  : %s\n",p_system_info->rt_thread_version);

    rt_kprintf(" System Info Size   : %ld K\n",sizeof(system_info));

}

int at24(int argc ,char *argv[])
{
    at24cxx_device_t dev = RT_NULL;
    system_info at_r_info = {0};


    if (argc != 1)
    {
        rt_kprintf("error, usage:  at24\n");
        return -1;
    }

    system_info_init();
    dev = at24cxx_init("i2c1");

    at24cxx_write(dev, 0, (uint8_t *)&at_system_info, sizeof(system_info));
    rt_kprintf("write system info ok\n");

    at24cxx_read(dev,0,(uint8_t *)&at_r_info,sizeof(system_info));
    system_info_show(&at_r_info);

    at24cxx_deinit(dev);

    return 0;
}

MSH_CMD_EXPORT(at24, at24cxx eeprom test);
#endif

.h文件

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2019-04-13     XiaojieFan   the first version
 * 2019-12-04     RenMing      Use PAGE WRITE instead of BYTE WRITE and input address can be selected
 */

#ifndef __AT24CXX_H__
#define __AT24CXX_H__

#include <rthw.h>
#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

#define AT24C01     0
#define AT24C02     1
#define AT24C04     2
#define AT24C08     3
#define AT24C16     4
#define AT24C32     5
#define AT24C64     6
#define AT24C128    7
#define AT24C256    8
#define AT24C512    9
#define AT24CTYPE   10   // Number of supported types

#define EE_TWR      5

#ifndef EE_TYPE
#define EE_TYPE     AT24C02
#endif

struct at24cxx_device
{
    struct rt_i2c_bus_device *i2c;
    rt_mutex_t lock;
};

typedef struct 
{
    char     version[24];
    uint32_t sysclk;
    uint32_t hclk;
    uint32_t apb1_clk;
    uint32_t apb2_clk;
    uint32_t ramsize;
    uint32_t romsize;
    char     eep_type[24];
    char     rt_thread_version[48];

}system_info;


typedef struct at24cxx_device *at24cxx_device_t;

extern at24cxx_device_t at24cxx_init(const char *i2c_bus_name);
extern rt_err_t at24cxx_read(at24cxx_device_t dev, uint32_t ReadAddr, uint8_t *pBuffer, uint16_t NumToRead);
extern rt_err_t at24cxx_write(at24cxx_device_t dev, uint32_t WriteAddr, uint8_t *pBuffer, uint16_t NumToWrite);
extern rt_err_t at24cxx_page_read(at24cxx_device_t dev, uint32_t ReadAddr, uint8_t *pBuffer, uint16_t NumToRead);
extern rt_err_t at24cxx_page_write(at24cxx_device_t dev, uint32_t WriteAddr, uint8_t *pBuffer, uint16_t NumToWrite);

#endif

4、代码

代码下载

夏侯城临
关注
专栏目录
RT-thread学习笔记1 I2C设备驱动学习之EEPROM驱动(上)
mjc_1209的专栏
12-15 7365
RT-thread中关于I2C设备驱动主要有i2c_core.c、i2c_dev.c、i2c-bit-ops.c这个几个文件，这次的主要任务就是结合提供的i2c驱动库编写eeprom的读写函数，基于ALIENTEK MINI STM32作为开发平台。     第一步：由于RT-thread中的i2c-bit-ops.c文件中已经实现了i2c的总线驱动，我们只需要完成关于结构体rt-i2c-b
RT-Thread使用I2C读写eeprom例程（24c02）
yang1111111112的博客
10-22 8268
实验准备： 开发板：正点原子探索者 RT-Thread源码 env工具 env配置： 使能相关的uart，用于打开控制台 打开I2C设备：   实验源代码： #include &lt;rtthread.h&gt; #include &lt;rtdevice.h&gt; #ifndef EEP_I2CBUS_NAME #define EEP_I2CBUS_NAME ...
IIC总线协议---以存储芯片at24c64为例
热门推荐
朱工的专栏
03-08 1万+
IIC总线协议 前言:年前给老师做个红外抄表系统,,现在对当中用到的一些模块总结一下. 1.只有在总线空闲时才允许启动数据传送.2.在数据传送过程中,当时钟线为高电平时,数据线必须保持稳定状态,不允许有跳变.时钟线为高电平时,数据线的任何电平变化将被看做总线的起始或停止信号.3. 任何将数据传送到总线的器件作为发送器任何从总线接收数据的器件为接收器, 主器件和从器件都可以作
RT-Thread之旅：IIC设备之AT24C02
Argon_Ghost的博客
02-04 3469
工程创建 我使用的开发板是正点原子的STM32F1精英板，所以在建立工程的时候配置如下（我使用的是盗版的精英版，所以在选择调试工具的时候要选择SWO模式，因为板子没连JTAG的模式的线）： 加载驱动 加载模拟I2C驱动 因为我们要测试的是一个IIC设备，这里我们就使用STM32板载的AT24C02芯片来当作待测芯片。因为STM32硬件IIC在设计之初就存在一定的缺陷，所以一般我们都是采...
RT-Thread Studio----STM32F107学习笔记2--添加AT24CXX软件包
吴小锅的博客
07-26 443
1、在RT-Thread Studio中添加软件包的方式 使用I2C操作AT24C64。3、根据I2C Config进行相应步骤配置。6、使用以及运行结果。
rtthread iic读取M24C64的测试程序
杨飞的博客
02-23 1240
先加软件包 下面两个参数根据实际情况修改 修改board.h里面的引脚定义 添加驱动 /********EEPROM掉电保存*********/ uint8_t IIC2_WriteBuffer_Test[16], IIC2_ReadBuffer_Test[16]; void iic_write_test(void)//iic写 { uint16_t i; for(i=0; i<16; i++) IIC2_WriteBuffer_Test[i
RT-Thread： eeprom存储芯片 at24cxx软件包使用流程
yutian0606的博客
01-15 1162
说明：介绍 i2c 通讯接口的eeprom at24cxx 读写测、试代码，代码基于 at24cxx 软件包实现
NUCLEO-F411RE RT-Thread 体验 (1) - GCC环境 RT-Thread 的移植
weixin_43932857的博客
06-19 546
平时用的是iMac以及MacBook，所以烧录我用的是pyocd，将烧录命令添加到Makefile里，执行make的时候，就会自动烧录软件。因为entry往下执行，会调用到rtthread_startup()函数，这个函数里的rt_hw_board_init需要自己定义。因为这个rtconfig.h的配置比较全，所以也包含了finsh组件，而我们前面并没有将finsh编译进去。编译通过，烧录进去后，灯在闪烁，那么RT-Thread跑起来了吗？很遗憾，并没有，现在还是裸机程序再跑，继续修改。
NUCLEO-F411RE原理图 PCB图资料分享
11-01
"NUCLEO-F411RE原理图 PCB图资料分享"提供的内容是该开发板的设计基础，对理解硬件工作原理和进行二次开发至关重要。 首先，"SCH"文件代表原理图(Schematic)，它展示了电路的电气连接和组件布局。在STM32F411RE的...
Nucleo-F411RE板子原理图
07-13
**Nucleo-F411RE板子原理图详解** Nucleo-F411RE是意法半导体（STMicroelectronics）推出的一款基于ARM Cortex-M4内核的微控制器开发板，它集成了STM32F411RET6芯片。这款开发板的设计目的是为嵌入式开发者提供一个...
nucleo-F411RE Template工程模板-点亮LD2.rar
05-14
STM32 nucleo-F411RE开发板是一款由STMicroelectronics推出的微控制器开发平台，主要面向嵌入式系统设计者。它采用ARM Cortex-M4内核，具有高性能、低功耗的特点，适用于各种嵌入式应用。在这个“nucleo-F411RE ...
应用笔记NUCLEO-G474RE+开发板扩展+LSM6DSO+实现+Data+Fusion+演示
03-15
NUCLEO-G474RE开发板提供了易于使用的硬件资源和软件开发环境，非常适合进行原型设计和快速开发。 #### 4. Unicleo-GUI工具介绍 Unicleo-GUI是一款图形用户界面工具，专为STM32微控制器上的MEMS传感器设计。它允许...
NUCLEO-F411RE开发板原理图和PCB源文件
02-26
《深入解析NUCLEO-F411RE开发板：从原理图到PCB设计》 在嵌入式系统开发领域，STM32系列微控制器以其高性能、低功耗的特点深受工程师喜爱。其中，NUCLEO-F411RE开发板是基于STM32F411RET6微控制器的一款入门级开发...
TIM定时中断
m0_63690570的博客
09-28 320
基本定时器（APB1）：TIM6、TIM7拥有定时中断、主模式触发DAC的功能。通用定时器（APB1）：TIM2、TIM3、TIM4、TIM5拥有基本定时器全部功能，并额外具有内外时钟源选择、输入捕获、输出比较、编码器接口、主从触发模式等功能。高级定时器（APB2）：TIM1、TIM8拥有通用定时器全部功能，并额外具有重复计数器、死区生成、互补输出、刹车输入等功能。STM32F103C8T6定时器资源：TIM1、TIM2、TIM3、TIM4。
STM32精确控制步进电机
qq_23313467的博客
09-22 840
10mm二相四线微型步进电机电机输出是4个引脚，需要自己焊机线，相电阻53欧，步进角度估计18度，丝杆滑块行程32mm，丝杆转一圈铜滑块大约移动行程0.4mm。3. 安全考虑：控制脉冲的最大输出数量，持续脉冲输出的时间。1. 主程序设置电机的启动、停机、运动方向、运动的步数。目的：学习使用STM32+电机驱动器+步进电机，进行电机运动精确控制。在步进电机不堵转的情况下，可以实现移动距离的精确控制。关键代码一：在脉冲计数的回调函数对数据脉冲数量进行控制。一. 电机和A4999之间的连接。
STM32-HAL库驱动DHT11温湿度传感器 --2024.9.28
最新发布
qq_45784265的博客
09-28 606
本教程用通俗易懂的语言和详细的操作过程截图，为开发者清除DHT11这只拦路虎，本教程还提供可以快速使用DHT11的驱动代码，只要跟着本教程操作，都可以正确读取到温湿度信息。
stm32 FLASH闪存(读写内部FLASH&读取芯片ID)
2302_79504723的博客
09-21 1570
STM32F1系列的FLASH包含程序存储器、系统存储器和选项字节三个部分，通过闪存存储器接口（外设）(FLASH管理员)可以对程序存储器和选项字节进行擦除和编程读写FLASH的用途：利用程序存储器的剩余空间来保存掉电不丢失的用户数据通过在程序中编程（IAP），实现程序的自我更新在线编程（In-Circuit Programming – ICP）用于更新程序存储器的全部内容，它通过JTAG（stm32特有协议）、SWD协议（通用协议）或系统加载程序（Bootloader）下载程序。
STM32 MCU学习资源
qq_50930131的博客
09-19 608
作者: @bushuo联系方式: 3513566868@qq.com。
NUCLEO-F411RE
07-31
NUCLEO-F411RE是一款开发板，它具有一个8M的晶振，用于提供时钟给st-link。因此，可以推测F411RE的时钟来源是来自st-link的mco输出，频率为8M。此外，NUCLEO-F411RE还支持虚拟串口功能，通过初始化PA2和PA3为串口功能，可以直接使用st-link进行数据的抓取和打印，而无需额外接USB转串口模块。为了使用letter shell，需要将串口配置为tx rx模式，并使用普通轮询模式发送数据，使用中断模式接收数据。中断函数每次接收到一个数据时调用一次，可以在中断函数中调用shellHandler(&shell, received_char)来处理数据。[1][3]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值