[STM32H7] 【银杏科技ARM+FPGA】分享iCore4T移植RT-Thread过程的点点滴滴

[复制链接]
28943|373
pkoko 发表于 2020-3-14 16:07 | 显示全部楼层
支持楼主,建议把你的BSP贡献给rt-thread,放到rt-thread的发布版本中,这样有助于icore的应用推广
王紫豪 发表于 2020-3-14 21:29 | 显示全部楼层
pkoko 发表于 2020-3-14 16:07
支持楼主,建议把你的BSP贡献给rt-thread,放到rt-thread的发布版本中,这样有助于icore的应用推广 ...

正在弄呢。
晓阳L 发表于 2020-3-18 08:56 | 显示全部楼层
讲解的很详细,好好学习一下!
石墨星海 发表于 2020-3-19 12:04 来自手机 | 显示全部楼层
感谢分享
GT01115 发表于 2020-4-9 17:56 | 显示全部楼层
很详细呀厉害厉害
GT01115 发表于 2020-4-14 16:14 | 显示全部楼层
支持支持,跟着学的
GT01115 发表于 2020-4-18 20:01 | 显示全部楼层
反复学习
shcnxjy 发表于 2020-4-19 08:56 | 显示全部楼层
感谢分享,学习了!
 楼主| heart蓝色CD 发表于 2020-4-20 15:52 | 显示全部楼层
本帖最后由 heart蓝色CD 于 2020-4-20 16:51 编辑

分享iCore4T移植RT-Thread过程的点点滴滴——DAY 8

高手请略过,如有错误请多多批评指点!

iCore4T ARM+FPGA双核心板I2C总线挂有三个设备,分别为AXP152电源管理芯片,LM75A温度传感器,EEPROM存储器,在DAY 7里我给大家分享了LM75A驱动的添加过程,今天我给大家分享最后一个I2C设备EEPROM驱动的添加过程。

EEPROM是一个带电可擦可编程只读存储器,iCore4T ARM+FPGA双核心板挂有一片容量为4KBit的EEPROM可用于一些参数信息的存储。

1、修改kconfig文件,在menuconfig中添加配置EEPROM的选项。
day8_1.png

2、添加eeprom驱动程序,并将该文件放在../bsp/stm32/libraries/HAL_Drivers,我把源码贴在下面。
  1. /*
  2. * Copyright (c) 2006-2018, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date           Author       Notes
  8. * 2020-02-17     zh.          first version
  9. */

  10. #include <board.h>
  11. #include <drv_qspi.h>
  12. #include <rtdevice.h>
  13. #include <rthw.h>
  14. #include <finsh.h>

  15. #ifdef BSP_USING_I2C_EEPROM

  16. /* For eeprom i2c bus*/
  17. #define EEPROM_I2CBUS_NAME     "i2c1"
  18. #define _24LC04B                                                            (0xA0 >> 1)

  19. static struct rt_i2c_bus_device *eeprom_i2c_bus = RT_NULL;

  20. static rt_err_t i2c_write_nbyte(rt_uint8_t slave_addr, rt_uint8_t cmd, rt_uint8_t *value, rt_uint32_t len)
  21. {
  22.     rt_uint32_t i;
  23.     rt_uint8_t *buffer;
  24.     rt_size_t result;
  25.         
  26.     buffer = rt_malloc(len + 1);
  27.         
  28.     buffer[0] = cmd;
  29.         for(i  = 0;i < len;i ++)
  30.         {
  31.                 buffer[i+1] = value[i];
  32.         }        
  33.     result = rt_i2c_master_send(eeprom_i2c_bus, slave_addr, RT_I2C_WR, buffer, len+1);
  34.         
  35.         rt_free(buffer);
  36.         
  37.     if (result == (len+1))
  38.     {
  39.         return RT_EOK;      
  40.     }
  41.     else
  42.     {
  43.         return -RT_ERROR;      
  44.     }
  45. }

  46. static rt_err_t i2c_read_nbyte(rt_uint8_t slave_addr, rt_uint8_t cmd, rt_uint8_t *buf, rt_uint32_t len)
  47. {
  48.     rt_i2c_master_send(eeprom_i2c_bus, slave_addr, RT_I2C_WR, &cmd, 1);
  49.    
  50.     rt_i2c_master_recv(eeprom_i2c_bus, slave_addr, RT_I2C_RD, buf, len);
  51.    
  52.     return RT_EOK;
  53. }

  54. rt_uint32_t eeprom_write(rt_uint32_t addr, rt_uint8_t dat)
  55. {
  56.         rt_uint8_t madd;

  57.         if (addr > 255)
  58.         {
  59.                 /* select block 0~255 / 256 ~ 511 */
  60.                 madd = _24LC04B | 0X01;
  61.                 addr -= 256;
  62.         }
  63.         else
  64.         {
  65.                 madd = _24LC04B;
  66.         }
  67.         
  68.         i2c_write_nbyte(madd, addr, &dat, 1);

  69.         rt_thread_mdelay(10);

  70.         return 0;
  71. }

  72. rt_uint8_t eeprom_read(rt_uint32_t addr)
  73. {
  74.         rt_uint8_t madd;
  75.         rt_uint8_t dat;

  76.         if(addr > 255)
  77.         {
  78.                 /* select block 0~255 / 256 ~ 511 */
  79.                 madd = _24LC04B | 0X01;
  80.                 addr -= 256;
  81.         }
  82.         else
  83.         {
  84.                 madd = _24LC04B;
  85.         }

  86.         i2c_read_nbyte(madd, addr, &dat, 1);

  87.         return dat;
  88. }
  89. static int eerpom_init(void)
  90. {
  91.         eeprom_i2c_bus = rt_i2c_bus_device_find(EEPROM_I2CBUS_NAME);

  92.     if(eeprom_i2c_bus == RT_NULL)
  93.     {
  94.         rt_kprintf("i2c_bus %s for lm75a not found!\n", eeprom_i2c_bus);
  95.         return -RT_ERROR;                        
  96.     }
  97.         else
  98.         {
  99.                 return RT_EOK;
  100.         }
  101. }
  102. INIT_COMPONENT_EXPORT(eerpom_init);

  103. static int eeprom(int argc, char **argv)
  104. {
  105.         int i;
  106.         unsigned char write_buffer[512];
  107.         unsigned char read_buffer[512];
  108.         int result = RT_EOK;
  109.         int address;
  110.         unsigned char data;
  111.         int errors = 0;
  112.         
  113.     if (argc > 1)
  114.     {
  115.                 if(!strcmp(argv[0],"eeprom"))
  116.                 {
  117.                         if (!strcmp(argv[1], "write"))
  118.                         {
  119.                                 if (argc == 4)
  120.                                 {
  121.                                         address = atoi(argv[2]);
  122.                                         data = atoi(argv[3]);
  123.                                         if(address < 512 && data <= 255)
  124.                                         {
  125.                                                 rt_kprintf("address:%d data:%d\n",address,data);
  126.                                                 eeprom_write(address,data);
  127.                                         }
  128.                                         else
  129.                                         {
  130.                                                 rt_kprintf("address or data is error!\n");
  131.                                         }
  132.                                 }
  133.                                 else
  134.                                 {
  135.                                         rt_kprintf("Bad command. Please enter 'eeprom' for help\n");
  136.                                 }
  137.                         }
  138.                         else if (!strcmp(argv[1], "read"))
  139.                         {
  140.                                 if (argc == 3)
  141.                                 {
  142.                                         address = atoi(argv[2]);
  143.                                        
  144.                                         if(address < 512)
  145.                                         {
  146.                                                 data = eeprom_read(address);
  147.                                                 rt_kprintf("Read eeprom address %d is %d\n",address,data);
  148.                                         }
  149.                                         else
  150.                                         {
  151.                                                 rt_kprintf("address is error!\n");
  152.                                         }
  153.                                 }
  154.                                 else
  155.                                 {
  156.                                         rt_kprintf("Bad command. Please enter 'eeprom' for help\n");
  157.                                 }
  158.                         }
  159.                         else if (!strcmp(argv[1], "test"))
  160.                         {
  161.                                 if (argc == 2)
  162.                                 {
  163.                                         for(i = 0;i < 512;i ++)
  164.                                         {
  165.                                                 write_buffer[i] = i % 256;
  166.                                         }
  167.                                        
  168.                                         for(i = 0;i < 512;i ++)
  169.                                         {
  170.                                                 eeprom_write(i,write_buffer[i]);
  171.                                         }
  172.                                        
  173.                                         for(i = 0;i < 512;i ++)
  174.                                         {
  175.                                                 read_buffer[i] = eeprom_read(i);
  176.                                         }
  177.                                        
  178.                                         for(i = 0;i < 512;i ++)
  179.                                         {
  180.                                                 if(read_buffer[i] != write_buffer[i])
  181.                                                 {
  182.                                                         errors ++;
  183.                                                         rt_kprintf("eeprom error:0x%02x 0x%02x\n",write_buffer[i],read_buffer[i]);
  184.                                                 }
  185.                                         }
  186.                                         if(errors)
  187.                                         {
  188.                                                 rt_kprintf("eeprom fail!\n");
  189.                                         }
  190.                                         else
  191.                                         {
  192.                                                 rt_kprintf("eeprom ok!\n");
  193.                                         }
  194.                                 }
  195.                                 else
  196.                                 {
  197.                                         rt_kprintf("Bad command. Please enter 'eeprom' for help\n");
  198.                                 }
  199.                         }
  200.                         else
  201.                         {
  202.                                 rt_kprintf("Bad command. Please enter 'eeprom' for help\n");
  203.                         }
  204.                 }
  205.                 else
  206.                 {
  207.                         rt_kprintf("Bad command. Please enter 'eeprom' for help\n");
  208.                 }
  209.     }
  210.     else
  211.     {
  212.         rt_kprintf("Usage: \n");
  213.         rt_kprintf("eeprom write <address> <data>   - write data to eeprom\n");
  214.         rt_kprintf("eeprom read  <address>          - read data from eeprom\n");
  215.         rt_kprintf("eeprom test                     - write & read test eeprom\n");
  216.         result = -RT_ERROR;
  217.     }
  218.         
  219.     return result;
  220. }
  221. MSH_CMD_EXPORT(eeprom, eeprom function);
  222. #endif /* BSP_USING_I2C_EEPROM */

3、打开该文件夹下的SConscript文件,添加文件路径,这样生成工程的时候可以自动将该文件加入MDK工程。
day8_2.png

4、进入stm32h750-gingko-icore4t文件夹下,右击选择ConEmu Here,打开menuconfig,配置EEPROM。
day8_3.png

5、使用scons命令,键入scons --target=mdk5,生成MDK5工程,编译,烧录,就可以进行EEPROM测试了。

6、打开终端,键入eeprom,我们可以看到共有三个函数分别为eeprom测试函数,eeprom写函数,eeprom读函数。
day8_4.png

7、读写测试eeprom为整片读写测试,键入eeprom test,测试完成后弹出测试结果。
day8_5.png

8、单字节读写操作,我们向空间地址300,写入数据111,并读出进行测试。
day8_6.png

至此说明我们的eeprom驱动已经添加成功。

9、源代码
        源代码可以稳步这里下载:
        链接:https://pan.baidu.com/s/1fcLU4WaRDlgr0mNYwZj1Yg  提取码:zstq
        我将在DAY9里面为大家分享W25Q64加入文件系统的过程。


GT01115 发表于 2020-5-7 18:08 | 显示全部楼层
又来学习了,今天学习SPI
xiaolin1111 发表于 2020-6-15 10:41 | 显示全部楼层
学习学习
GT01115 发表于 2020-6-20 16:56 | 显示全部楼层
顶顶顶
abin0415 发表于 2020-7-8 10:41 | 显示全部楼层
感谢楼主的分享
GT01115 发表于 2020-9-10 11:06 | 显示全部楼层
跟着学习挂载驱动,楼主无偿奉献呀
caigang13 发表于 2020-9-11 08:14 来自手机 | 显示全部楼层
不错,感谢楼主分享
便携手到老 发表于 2020-9-11 08:45 | 显示全部楼层
RT-Thread,全称是 Real Time-Thread,顾名思义,它是一个嵌入式实时多线程操作系统。
明天真的好 发表于 2020-9-11 09:01 | 显示全部楼层
git下载地址:https://git-scm.com/downloads。
可爱的烧饼 发表于 2020-9-11 09:38 | 显示全部楼层
Env是RTT推出的开发辅助工具,针对基于RTT操作系统项目工程,提供编译构建环境、图形化系统配置及软件包管理功能,其内置的menuconfig提供了简单易用的配置剪裁工具,可对内核、组件和软件包进行自由剪裁,使用系统以搭积木的方式进行构建。
quickman 发表于 2020-9-12 22:40 | 显示全部楼层
stm32用 rt-thread操作系统的串口收发 简单例程?
jstgotodo 发表于 2020-9-12 22:40 | 显示全部楼层
rt-thread 怎样修改shell调试串口
您需要登录后才可以回帖 登录 | 注册

本版积分规则

快速回复 在线客服 返回列表 返回顶部