单片机编程之 - 程序模块化及可复用性（二）

electrlife

单片机编程之 - 程序模块化及可复用性（二）

单片机编程之 - 程序模块化及可复用性（一）
http://www.amobbs.com/thread-5580954-1-1.html

关于这个贴子的原由请查看http://www.amobbs.com/thread-5580903-1-1.html
另外申明：技术只是实现产品的一种工具，因此你应该花更多的时间去关注产品的本身！

    终于开始写第二节了，如果你已经认真看完第一节，你应该多少对面象接口这种形式的程序方法有所感觉了，
此刻你应该已经试着把以前的各个传感器的驱动改成这种形式了！如果你还没有，那开始阅读这节之前，先
简单实践下吧！

   上一节中我们实现了两个模块，一个是软件IIC模块，另一个是EEPROM 24LC512模块，有了这两个模块，接下来
我们就开始学习如何使用这个EEPROM。在使用EEPROM之前，我把上一节的关于EEPROM面要考虑的问题再次复制过来：

1、EEPROM一般做什么使用
2、EEPROM的操作如何在多任务中使用
3、如何避免错误程序的多次误写（EEPROM有擦除次数的）
4、EEPROM如何考虑写时掉电,且如何识别错误并恢复
5、如何提高EEPROM的写效率，即那写的10MS延时

首先我们解决 1、EEPROM一般做什么使用？
我们知道EEPROM一般都是作为参数存储使用的，如传感器的校准系数、产品
生产日期、产品名称等等。那如何组织这些信息并进行管理呢？
我想最原始的方法应该主是类似如下这样：

1. 
   
2. #define EEP_ADC_PARAM_OFFSET        0x100
   
3. #define EEP_PRODUCT_TYPE_OFFSET     0x104
   
4. #define EEP_PRODUCT_NAME_OFFSET     0x108
   
5. 
   
6. int test_eeprom_param(void)
   
7. {
   
8.     uint32_t adc_param;
   
9. 
   
10.     return dev_24lcxx_read(&dev_ee24lc512, EEP_ADC_PARAM_OFFSET, &adc_param, sizeof(adc_param));
    
11. }

复制代码

如果你还在用以上方式，你千万不要说出来，因为太原始了，太暴力了！:-) ！
这种方式的最大问题是，当你发现你先前定义的一个参数的字节设的太小时，
你需要更改所有参数的偏移量，对于我这样的懒人来说这是个巨大的工作量。
而这些工作其实可以让编译器来完成，如下所示：

1. 
   
2. struct nvram_sysparam {
   
3.     uint32_t    type;               /* 设备类型   */
   
4.     uint32_t    rev;                /* 设备版本号 */
   
5.     char        sn[32];             /* 设备序列号 */
   
6.     char        name[32];           /* 设备名称   */
   
7. 
   
8.     uint32_t    adc_param;
   
9. };
   
10. 
    
11. #define plat_offsetof(type, member)         ((unsigned long)(&((type *)0)->member))
    
12. 
    
13. int test_eeprom_param(void)
    
14. {
    
15.     uint32_t adc_param;
    
16. 
    
17.     return dev_24lcxx_read(&dev_ee24lc512, plat_offsetof(struct nvram_sysparam, adc_param),
    
18.                          &adc_param, sizeof(adc_param));
    
19. }

复制代码

有了上述的改变，我们可以省去了计算各个参数偏移量的工作，当增加新的参数或是改变老的参数
后，plat_offsetof宏这义会自动帮我们计算。但在这里我们发现还有一个小问题就是关于参数的字节
数，当调用dev_24lcxx_read函数时我们应当以EEPROM存储的这个参数的字节数为准，因此sizeof(adc_param)
这种做法不是推荐的，如果EEPROM里参数的字节数发生变化，那么你的应用程序用所有和这个参数的相关的操作
都得重新改过，这是我这种懒人地接受的，因此你需要下面的宏及使用方式：

1. 
   
2. #define plat_offsetof(type, member)         ((unsigned long)(&((type *)0)->member))
   
3. #define plat_paramsizeof(type, member)      (sizeof(((type *)0)->member))
   
4. 
   
5. int test_eeprom_param(void)
   
6. {
   
7.     /* 注意这里需要对其进行赋值为0操作 */
   
8.     uint32_t adc_param = 0;
   
9. 
   
10.     return dev_24lcxx_read(&dev_ee24lc512, plat_offsetof(struct nvram_sysparam, adc_param),
    
11.                          &adc_param, plat_paramsizeof(struct nvram_sysparam, adc_param));
    
12. }

复制代码

     好了到这里我们已经可以很方便增加改变EEPROM中参数的大小了，这所有改变几乎不影响应用程序。
如果对于小型的MCU开发，或是资源紧张的MCU写到里或许已经可以很好的使用了，唯一的遗憾是对于
函数中    uint32_t adc_param = 0; 变量，我们在定义时需要初始化并定义此变量比实际EEPROM中
的字节数多，至少应该相等。这点需要特别注意！但是我们不应该只满足于此，上面两种方式都存在
一个共同的问题，就是可维护性！如果出现以下情景你该如何处理？

1、你的程序处于调试阶段，struct nvram_sysparam 结构的成员基本是每天都要增加
   当你辛苦用万用表调整的ADC系数，因为你的增加新参数导致其偏移改变，所以不得
   不重新使用万用表调整的ADC系数，当这种参数如果有几十个时，我相信你会崩溃！
2、你的程序已经运行在设备上，但当某人市场部提出增加新功能时，你不得不给老机器升级
   程序，但你发现新功能需要新的参数增加时，你傻眼了，以前的设备运行时的参数及数据都
   需要重新输入，这时候你还会崩溃的！
   
      有人看了以上问题，可能会说，这还不简单吗，我增加新的参数时只从struct nvram_sysparam最后
加入，那以上问题不是都解除了吗？的确这样确实是可以解决，但是这种方式是行不通的，至于原因
请住后看。

      上面说了那么多，其实都不是今天的主题，只是餐前开胃，接下来才是今天的正餐：
      
程序模块化及可复用性的原则三：应用模块接口尽量使用ASCII字符格式而非二进制流格式

为了大家能时刻记住前面说过的原则，我再次复制过来：

程序模块化及可复用性的原则一：面像接口编程
程序模块化及可复用性的原则二：硬件的抽象接口尽量通用简单

    对于 程序模块化及可复用性的原则三，真可谓是无边无际，往大了说可能我自己也都是门外汉，因此
我只能住小了说：:-)，对于这个原则我不想作过多的解释，因为我觉得如果你真要想感受到此原则的好处
确实是需要实际使用中体会！好了开始我们今天的正餐程序模块化及可复用性。

    我们知道在前面一节当中我们对两个设备进行了抽象，一个是IIC，一个EEPROM，细心的读者或许会发现
前的抽象都是针对具体的设备，也就是这种设备是看的到，摸得着的，它们都有很规范的操作时序及操作集合，
因此在进行抽象时并不是特别困难。接下来我们说下关于一些看不到摸不着的设备抽象：

    有了上面的EEPROM管理的基础，我们现在想想我们需要一个统一的EEPROM管理操作集合供上层应用代码，
那么如何把这些集合操作组织起来呢？下面就看下我的做法，当然可能别人还有更出色的做法！对于EEPROM
或是FRAM之类的这种非易失性的存储器我统称他们为NVRAM，对于NVRAM我们需思考给上层怎样的接口，或者
上层需要什么时候样的接口功能，为了程序的通用和模块化，因此我们需要一个完善的NVRM接口及功能，而
具体的功能如下：

1、允许拥有多的NVRAM，且这些NVRAM可以是不同或是相同类型
2、应用程序不需要知道是什么类型的NVRAM，应用程序都视一种设备NVRAM，统一管理
3、多个不同或是相同的NVRAM在应用层可合并成一个大容量的NVRAM使用
4、当然应用程序也可以把一个NVRAM设备分成多个区分并作为多个NVRAM使用
5、NVRAM设备具有错误识别及自动恢复能力，也即写时掉电的问题

    有了上面的要求，我们就有了目标，接下来就可以向着目标前进了！到这里似乎来原则三还没有什么
关系，别着急接下来你就可以看到了！

electrlife

首先我们先设计出NVRAM给应用层的接口，注意设计接口的原则，我的设计如下所示

1. 
   
2. int nvram_set(struct nvram_partition *partition, const char *name,
   
3.               const char *buf, int size);
   
4. 
   
5. int nvram_get(struct nvram_partition *partition, const char *name,
   
6.               char *buf, int size);
   
7. 
   
8. int nvram_set_ulong(struct nvram_partition *partition, const char *name,
   
9.                     unsigned long value);
   
10. 
    
11. int nvram_get_ulong(struct nvram_partition *partition, const char *name,
    
12.                     unsigned long *value);

复制代码

     这里我对部分参数进行一下说明：
struct nvram_partition *partition 表示指向分区的指针，因为我们要求NVRAM是可以以分区的形式进行操作的，因此我们的函数
的基本结构应该是以分区作为对象的，这点需要理解。
const char *name 表示你需要读取的参数的名称，注意，这里使用了名称来操作NVRAM分区中的参数，这个是重点，也正是体现了
“程序模块化及可复用性的原则三：应用模块接口尽量使用ASCII字符格式而非二进制流格式”这条原则，有了这个名字，大家肯定都
会想到我们是需要把名称和对应的变量进行联系的，对的！
     后面的两个函数 nvram_set_ulong、nvram_get_ulong是为了方便操作而设立的，因为NVRAM中的参数一般的大小都不会超过4个字节
因此通过这两个函数可以很容易的设定NVRAM中各个变量的值。这里需要说明的是此函数应该自动依据NVRAM中变量的字节长度来截取
输入参数unsigned long value的值。有了这两个函数，你也可以根据实际上情况，增加nvram_set_float等方便操作的函数。好了，有了
上面的操作，下面该想分区对象了，想想为了满足上面的应用，分区对象应该需要具有哪些信息呢，现在给出我的设计如下：

1. 
   
2. #define NVRAM_FLAGSINFO_VALID                   0xeaf5dca5
   
3. 
   
4. #define NVRAM_PARAM_TYPE_UVALUE                 0
   
5. #define NVRAM_PARAM_TYPE_SVALUE                 1
   
6. #define NVRAM_PARAM_TYPE_STRING                 2
   
7. 
   
8. #define NVRAM_PARAM_ATTR_SUPER                  0x00
   
9. #define NVRAM_PARAM_ATTR_USER                   0x01
   
10. 
    
11. struct nvram_hdr {
    
12.     uint32_t flags;
    
13.     uint32_t verify_crc;
    
14.     uint32_t len;
    
15.     uint32_t data[1];
    
16. };
    
17. 
    
18. struct nvram_param_info {
    
19.     const char *name;
    
20.     uint32_t    offset;
    
21.     uint16_t    n_byte;
    
22.     uint8_t     type;
    
23.     uint8_t     attribute;
    
24. };
    
25. 
    
26. /* NVRAM分区信息 */
    
27. struct nvram_partition {
    
28.     char *name;                 /* 名称 */
    
29.     struct nvram_chip *chip;    /* 分区属于哪个NVRAM设备 */
    
30.     unsigned long offset;       /* 分区在NVRAM设备中的偏移量 */
    
31.     unsigned long size;         /* 分区的大小 */
    
32. 
    
33.     char *cache_image;
    
34.     char *cache_addr;           /* 分区缓冲区首地址 */
    
35.     unsigned long total_cache_size;/* 分区有效数据的长度，单位（字节）*/
    
36.     struct nvram_param_info *tbl;/* 分区中变量名称与地址映射表 */
    
37.     unsigned int tbl_size;
    
38. 
    
39.     OS_MUTEX *locker;           /* 分区访问互斥锁 */
    
40. };

复制代码

    关于这些结构体成员我就不再解释了，因为稍后你会看到代码，我想在源码里的使用你应该更容易理解！
但这里的一个成员我还是要说下：就是 struct nvram_chip *chip;    /* 分区属于哪个NVRAM设备 */
正如注释的那样，此变量是NVRAM与底层驱动的抽象，也即是和硬件相关联系的关键，有了个抽象我们就可以先不
用管硬件是什么器件了，就可以直接写上层的应用了，因此这个底层的抽象接口我们一定要设计好，其设计的原则是
什么呢还是那句老话：面象接口编程原则XXXXXXXXXX，这里就不再重复了！具体如下所示：

1. 
   
2. struct nvram_chip {
   
3.     char *name;
   
4.     unsigned long size;
   
5.     unsigned int  slave_addr;
   
6.     unsigned int  page_size;
   
7.     unsigned int  n_page;
   
8.     void         *page_buf;
   
9. 
   
10.     int (*write)(struct nvram_chip *thiz, unsigned long offset_addr,
    
11.                     const char *buf, int size);
    
12. 
    
13.     int (*read)(struct nvram_chip *thiz, unsigned long offset_addr,
    
14.                     char *buf, int size);
    
15. };

复制代码

    由于NVRAM一般是针对EEPROM这种设备也作用，因此对于底层的接口中对于EEPROM的属性部分的内容较多，如果你想在NOR或是其它
的一些存储设备上使用NVRAM，那这里你还需要加上这些设备所需要的特殊数据部分，而就目前而言我们不作更复杂的假设了，不然又得
绕进了。这里的NVRAM底层又重新抽象出了一种接口而没有直接使用struct dev_24lcxx的一个原因就是希望NVRAM更加的抽象而不紧紧针对
EEPROM，比如可能你的EEPROM设备是一个远程设备，即不要CPU板上，这个是有可能的，楼主的上一个项目就是如此，需要通过CAN总去设置
下位机的EEPROM，那么只要虚拟化一个struct nvram_chip即可，把write read等实现通过CAN总线发送即可。因此有了这个我们自己抽象
的接口，我们就能很方便的把我们的参数放到任何地方，:-)。

electrlife

有些网友提出来看起来比较费力，一部分原因可能是C语言还不够熟悉，当然我写的也比较粗，
如果因为编程语言不熟悉，就只能多看看书了，这里不可能对C语法的东西作说明，如果这样
那真的需要写的太多了，然而为了能更好帮助大家理解，对于以上的结构体我还是简单做下介绍：
struct nvram_hdr 是放在每个NVRAM分区的开始位置，也标识一个NVRAM设备

1. 
   
2. struct nvram_hdr {
   
3.     uint32_t flags;         /* 是一个标识符，表示EEPROM是否有效如果是一个已经初始化的EEPROM则其值应该是0xeaf5dca5 */
   
4.     uint32_t verify_crc;    /* 对EEPROM中的所有数据进行CRC32处理，也是通过这个CRC来检查EEPROM中的数据是否正确，
   
5.                                当然如果你的项目对EEPROM的数据的可靠性与完整性要求比较高，这里你也可以加上更复杂
   
6.                                的校验算法，如MD5等 */
   
7.     uint32_t len;           /* 表示整个NVRAM中有效数据长度 */
   
8.     uint32_t data[1];       /* 暂时没有使用，只作为NVRAM中头部信息与用户数据的分隔 */
   
9. };

复制代码

    在上面已经提到了，我们的接口函数使用字符串作为参数来对NVRAM中的变量进行访问，因此我们需要把字符串转化成对应的变量地址，
而下面的这个结构体struct nvram_param_info的作用就是把变量的地址与其名称进行映射。这种通过字符串查找来寻变量地址的方式
需要一定量的查找与比较，因此变量的名称应当尽量短，当然你也可以通过更先进的查找技术来解决这个问题，比如HASH查找等。

1. 
   
2. struct nvram_param_info {
   
3.     const char *name;       /* 变量的名字，是一个字符串 */
   
4.     uint32_t    offset;     /* 此变量在NVRAM设备的偏移量，即此变量的具体地址 */
   
5.     uint16_t    n_byte;     /* 此变量所占用的字节数，即变量的大小 */
   
6.     uint8_t     type;       /* 变量的类型，目前只支持有符号整形，无符号整形，
   
7.                                字符串，当然你也可以根据实际情况增加自己的类型及处理函数 */
   
8.     uint8_t     attribute;  /* 此变量的属性，主要的作用是，你可以为你的NVRAM中的变量设置不同的属性加以区分
   
9.                                一般我会把变量分为两种属性，一个是用户变量， 一个是系统变量，它们的属性不同，则当
   
10.                                用户需要恢复出厂时，则可以根据此属性来决定此变量是否需要被恢复，当然你也可以添加其它
    
11.                                的属性，比如写一次属性，只读属性等等 */
    
12. };

复制代码

     有了这个结构体struct nvram_param_info，我们就可以把相应的变量与其名称对应起来了，那是如何做的呢？

1. 
   
2. struct nvram_sysparam {
   
3.     struct nvram_hdr hdr;
   
4. 
   
5.     uint32_t    type;               /* 设备类型   */
   
6.     uint32_t    rev;                /* 设备版本号 */
   
7.     char        sn[32];             /* 设备序列号 */
   
8.     char        name[32];           /* 设备名称   */
   
9. 
   
10.     /* 以下是用户定义数据类型 */
    
11.     uint32_t    reserve32_1;
    
12.     uint16_t    reserve16_1;
    
13.     uint8_t     reserve08_1;
    
14. };

复制代码

     有了这个结构体，那我们下一步就是要把此结构体中的变量地址和其名称映射起来，这里说明下，一般我会直接
使用变量名作为其名称，那我们就需要定义如下数组：
static const struct nvram_param_info param_system_map_tbl[] = {
    {.name = "type", .offset = plat_offsetof(struct nvram_sysparam, type), ...},
    .......
};
     实在不好意思，写到这儿我就不想写了，太麻烦了，因此作为懒人的我肯定不会手动去一个一个去设置了。
于是就有了下面的宏定义：

1. 
   
2. #define NVRAM_EXPORT_PARAM_UVALUE(type, param, attr)  \
   
3.     {#param, plat_offsetof(type, param), sizeof(((type *)0)->param), NVRAM_PARAM_TYPE_UVALUE, attr}
   
4. #define NVRAM_EXPORT_PARAM_SVALUE(type, param, attr)  \
   
5.     {#param, plat_offsetof(type, param), sizeof(((type *)0)->param), NVRAM_PARAM_TYPE_SVALUE, attr}
   
6. #define NVRAM_EXPORT_PARAM_STRING(type, param, attr)  \
   
7.     {#param, plat_offsetof(type, param), sizeof(((type *)0)->param), NVRAM_PARAM_TYPE_STRING, attr}
   

复制代码

     有了上面的宏定义那我们刚才的初始化就相对来说就比较容易了：

1. 
   
2. static const struct nvram_param_info param_system_map_tbl[] = {
   
3.     NVRAM_EXPORT_PARAM_UVALUE(struct nvram_sysparam, type               ,NVRAM_PARAM_ATTR_SUPER),
   
4.     NVRAM_EXPORT_PARAM_UVALUE(struct nvram_sysparam, rev                ,NVRAM_PARAM_ATTR_SUPER),
   
5.     NVRAM_EXPORT_PARAM_STRING(struct nvram_sysparam, sn                 ,NVRAM_PARAM_ATTR_SUPER),
   
6.     NVRAM_EXPORT_PARAM_STRING(struct nvram_sysparam, name               ,NVRAM_PARAM_ATTR_SUPER),
   
7. 
   
8.     NVRAM_EXPORT_PARAM_UVALUE(struct nvram_sysparam, reserve32_1        ,NVRAM_PARAM_ATTR_SUPER),
   
9.     NVRAM_EXPORT_PARAM_UVALUE(struct nvram_sysparam, reserve16_1        ,NVRAM_PARAM_ATTR_SUPER),
   
10.     NVRAM_EXPORT_PARAM_UVALUE(struct nvram_sysparam, reserve08_1        ,NVRAM_PARAM_ATTR_SUPER),
    
11. };

复制代码

     当然这也不是最省心的方案，还有一种就是利用编译器及链接器对段(SECTION)控制来处理，但这种方法需要
对程序的编译链接具有一定的了解，而本文主要目的是程序的模块化及可复用性，因此这种方法这里就不提及了！
通过以上的展示大家应该明白一点上述的结构及成员的作用了吧，
     接下来我们就该该说NVRAM的驱动接口 struct nvram_chip 了，还记得前面我们已经实现了一个抽象的设备了吧
对的，我们已经有了一个EEPROM的抽象设备，现在是时个使用它了，我们把此设备引用过来而且我们还需要实现两个
struct nvram_chip的函数，read 与 write，具体的代码如下所示：

1. 
   
2. extern const struct dev_24lcxx dev_ee24lc512;
   
3. 
   
4. static OS_MUTEX ee24lc512_lock;
   
5. 
   
6. static int eep_24lc512_write(struct nvram_chip *thiz, unsigned long offset_addr, const char *buf, int size)
   
7. {
   
8.     OS_ERR os_err;
   
9.     int r;
   
10. 
    
11.     if (!thiz) {
    
12.         return -1;
    
13.     }
    
14. 
    
15.     OSMutexPend(&ee24lc512_lock, 0, OS_OPT_PEND_BLOCKING, 0, &os_err);
    
16. 
    
17.     r = dev_24lcxx_write(&dev_ee24lc512, offset_addr, buf, size);
    
18. 
    
19.     OSMutexPost(&ee24lc512_lock, OS_OPT_POST_NONE, &os_err);
    
20. 
    
21.     return r;
    
22. }
    
23. 
    
24. static int eep_24lc512_read(struct nvram_chip *thiz, unsigned long offset_addr, char *buf, int size)
    
25. {
    
26.     int r;
    
27.     OS_ERR os_err;
    
28. 
    
29.     if (!thiz) {
    
30.         return -1;
    
31.     }
    
32. 
    
33.     OSMutexPend(&ee24lc512_lock, 0, OS_OPT_PEND_BLOCKING, 0, &os_err);
    
34. 
    
35.     r = dev_24lcxx_read(&dev_ee24lc512, offset_addr, buf, size);
    
36. 
    
37.     OSMutexPost(&ee24lc512_lock, OS_OPT_POST_NONE, &os_err);
    
38. 
    
39.     return r;
    
40. }

复制代码

    有了上面的两个操作函数，接下来我们就可以定义struct nvram_chip这个抽象的设备了，具体如下所示:

1. 
   
2. #define EE_ADDR             0x00
   
3. #define EE_CMD_RD           0xA1
   
4. #define EE_CMD_WR           0xA0
   
5. #define EE_PAGESIZE         128
   
6. #define EE_PAGENUM          512
   
7. 
   
8. const struct nvram_chip nvram_ee24lc512 = {
   
9.     .name       = "ee24lc512",
   
10.     .size       = EE_PAGESIZE * EE_PAGENUM,
    
11.     .slave_addr = EE_ADDR,
    
12.     .page_size  = EE_PAGESIZE,
    
13.     .n_page     = EE_PAGENUM,
    
14.     .page_buf   = 0,
    
15.     .write      = &eep_24lc512_write,
    
16.     .read       = &eep_24lc512_read,
    
17. };

复制代码

      从上面的代码中我们可以看出，如果哪天你的板子把EEPROM换成FRAM了，或是其它的存储介质，那么，你只需要重新
构建一个struct nvram_chip并实现其驱动，上层的所有逻辑不用更改，看到了吧，这就是面像接口的魅力。现在万事俱备只欠
东风了，我们东风是什么呢，就是我们最终要构建的NVRAM设备！

electrlife

占位占位占位占位占位占位占位占位占位

Vampireyifeng

好东西，顶楼主

baoqi

支持楼主，长知识了

ijlc1314

顶楼主   

binaimei2007

顶楼主,写得好

DevLabs

先顶再看.

fengyunyu

有时间再学习！

xin

学习，学习

zyw19987

这样写很久了，楼主值得一顶啊！
让大家什么叫模块化编程

hyghyg1234

赶上这么好的文章，要细读了。

wtliu

这个观念很好，利于积累和提高。

electrlife

更新较慢，大家见谅啊！好久没打这么多字了！

mainbp

搬凳子，学习

ts-fjw

学习学习 手机看着好累呀

electrlife

昨天有点事耽搁了，今天继续啊！

radar_12345

如果国人有十分之一电工都像楼主这么无私，何愁中国硬软件赶不上美国

fengyun_524

好帖子，关于设计模型和设计思想我也看了很多书，面很广很大，感觉也是略懂，要真正用到实际的产品看法上，还是很难。。

LOVEDZKF

radar_12345 发表于 2014-5-16 11:06
如果国人有十分之一电工都像楼主这么无私，何愁中国硬软件赶不上美国

其实主要不是电工的问题。

eye

/// xxx.h

struct nvram_sysparam {
    uint32_t    type;               /* 设备类型   */
    uint32_t    rev;                /* 设备版本号 */
    char        sn[32];             /* 设备序列号 */
    char        name[32];           /* 设备名称   */

    uint32_t    adc_param;
};
static const struct nvram_sysparam *NVRAM_Data = 0;

/// xxx.c
#include "xxx.h"
dev_24lcxx_read(&dev_ee24lc512, NVRAM_Data->adc_param, &adc_param, sizeof(adc_param));

这样写可读性更加高一些。

eye

eye 发表于 2014-5-16 21:21
/// xxx.h

struct nvram_sysparam {

尤其在支持自动补全的编辑器里面。

wb503059722

支持楼主

abcdzhy

这种方式太好了，支持楼主，跟楼主学习

electrlife

      接下来就开始构建我们的NVRAM设备，对于NVRAM设备我们一般是为EEPROM作为存储介质的，而项目中EEPROM的第一次上电
总是空的，所以我们需要一个默认的参数列表，因此我们定义一个默认的参数列表放在程序代码里，当发现是一个新的或是无效的
EEPROM时就使用默认的参数来进行初始化。

1. 
   
2. static const struct nvram_sysparam nvram_sysparam_default = {
   
3.     .hdr                = {NVRAM_FLAGSINFO_VALID, 0, 0, 0},
   
4.     .type               = 0,
   
5.     .rev                = 0,
   
6.     .sn                 = "N/A",
   
7.     .name               = "N/A",
   
8.     /* 以下是用户定义数据类型 */
   
9.     .reserve32_1        = 0,
   
10.     .reserve16_1        = 0,
    
11.     .reserve08_1        = 0,
    
12. };

复制代码

      我们的NVRAM设备需要在多任务环境下使用因此，我们需要进行临界段处理，即进行共享资源互斥，这里使用互斥信号，
而且为了快速对NVRAM进行处理，我们需要定义一个缓冲区来加速应用程序的访问。

1. 
   
2. extern const struct nvram_chip nvram_ee24lc512;
   
3. 
   
4. static OS_MUTEX sysparam_locker;
   
5. static struct nvram_sysparam sysparam_cache;
   
6. 
   
7. const struct nvram_partition sysparam_partition = {
   
8.     .name               = "sysparam_partition",                 /* 抽象设备的名称 */
   
9.     .chip               = (struct nvram_chip *)&nvram_ee24lc512,/* 底层驱动指针 */
   
10.     .offset             = 0,                                    /* 该分区位于NVRAM_CHIP设备的偏移量，因为一个NVRAM_CHIP可以
    
11.                                                                    拥有多个分区 */
    
12.     .size               = 1024*16,                              /* 该分区的大小 */
    
13. 
    
14.     .cache_image        = (void *)&nvram_sysparam_default,
    
15.     .cache_addr         = (void *)&sysparam_cache,
    
16.     .total_cache_size   = sizeof(sysparam_cache),
    
17.     .tbl                = (struct nvram_param_info *)&param_system_map_tbl[0],  /* 把NVRAM设备与对应的名称映射表进行绑定 */
    
18.     .tbl_size           = plat_countof(param_system_map_tbl),
    
19. 
    
20.     .locker             = &sysparam_locker,
    
21. };

复制代码

       到此我们的NVRAM设备已经抽象出来了，下面就是实现具体的接口函数了，这里我给出我实现这些接口函数的代码如下：

1. 
   
2. #define PARTITION_FLAGS_INVALID             1
   
3. #define PARTITION_CRC_VERIFY_FAILED         2
   
4. #define PARTITION_USE_DEFAULT_IMAGE         3
   
5. #define PARTITION_USE_BACKUP_IMAGE          4
   
6. #define PARTITION_CHIP_RW_ERR               5
   
7. 
   
8. #define get_partition_hdr(p)\
   
9.     ((struct nvram_hdr *)p->cache_addr)
   
10. 
    
11. #define get_chip_offset(p, offs)\
    
12.     (unsigned long)(p->offset + offs)
    
13. 
    
14. #define get_chip_bak_offset(p, offs)\
    
15.     (unsigned long)(p->offset + (p->size >> 2) + offs)
    
16. 
    
17. /**
    
18. * @brief  None.
    
19. *
    
20. * @param  partition
    
21. * @return
    
22. * @note   None.
    
23. */
    
24. static int init_partition_locker(struct nvram_partition *partition)
    
25. {
    
26.     OS_ERR os_err;
    
27. 
    
28.     OSMutexCreate(partition->locker, "partition locker", &os_err);
    
29. 
    
30.     if (os_err != OS_ERR_NONE) {
    
31.         kprintf("error:%u nvram partition create locker failed\n", os_err);
    
32.         return -1;
    
33.     }
    
34. 
    
35.     return 0;
    
36. }
    
37. 
    
38. static void lock_partition(struct nvram_partition *partition)
    
39. {
    
40.     OS_ERR os_err;
    
41. 
    
42.     OSMutexPend(partition->locker, 0, OS_OPT_PEND_BLOCKING, 0, &os_err);
    
43. }
    
44. 
    
45. static void unlock_partition(struct nvram_partition *partition)
    
46. {
    
47.     OS_ERR os_err;
    
48. 
    
49.     OSMutexPost(partition->locker, OS_OPT_POST_NONE, &os_err);
    
50. }
    
51. 
    
52. /**
    
53. * @brief  None.
    
54. *
    
55. * @param  partition
    
56. * @return
    
57. * @note   None.
    
58. */
    
59. static int chk_partition_info(struct nvram_partition *partition)
    
60. {
    
61.     struct nvram_chip *chip = partition->chip;
    
62. 
    
63.     if (!partition->name) {
    
64.         return -1;
    
65.     }
    
66. 
    
67.     if (!partition->chip) {
    
68.         return -1;
    
69.     }
    
70. 
    
71.     if (!partition->cache_image) {
    
72.         return -1;
    
73.     }
    
74. 
    
75.     if (!partition->cache_addr) {
    
76.         return -1;
    
77.     }
    
78. 
    
79.     if (!partition->cache_image) {
    
80.         return -1;
    
81.     }
    
82. 
    
83.     if (!partition->tbl) {
    
84.         return -1;
    
85.     }
    
86. 
    
87.     if (!partition->locker) {
    
88.         return -1;
    
89.     }
    
90. 
    
91.     if (partition->total_cache_size < 1) {
    
92.         return -1;
    
93.     }
    
94. 
    
95.     if (partition->size < (partition->total_cache_size * 2)) {
    
96.         return -1;
    
97.     }
    
98. 
    
99.     if (chip->size < partition->size) {
    
100.         return -1;
     
101.     }
     
102. 
     
103.     if ((partition->offset + partition->size) > chip->size) {
     
104.         return -1;
     
105.     }
     
106. 
     
107.     return 0;
     
108. }
     
109. 
     
110. /**
     
111. * @brief  计算CRC32.
     
112. *
     
113. * @param  partition
     
114. * @return
     
115. * @note   None.
     
116. */
     
117. static uint32_t calc_partition_cache_crc(struct nvram_partition *partition)
     
118. {
     
119.     uint32_t verify;
     
120.     unsigned long verify_size;
     
121.     struct nvram_hdr *hdr;
     
122. 
     
123.     hdr         = get_partition_hdr(partition);
     
124.     verify_size = ((unsigned char *)partition->cache_addr +
     
125.                    partition->total_cache_size) - (unsigned char *)hdr->data;
     
126. 
     
127.     // 计算参数区的crc32其中包括hdr区的数据data[1]内容
     
128.     verify = 0;
     
129.     verify = crc32(verify, (const unsigned char *)hdr->data, verify_size);
     
130. 
     
131.     return verify;
     
132. }
     
133. 
     
134. /**
     
135. * @brief  复制分区中默认的IMAGE数据到用户CACHE中供应用程序使用.
     
136. *
     
137. * @param  partition
     
138. * @return None.
     
139. * @note   None.
     
140. */
     
141. static void copy_default_image(struct nvram_partition *partition)
     
142. {
     
143.     struct nvram_hdr *hdr;
     
144.     hdr = (struct nvram_hdr *)partition->cache_addr;
     
145. 
     
146.     memcpy(partition->cache_addr, partition->cache_image,
     
147.            partition->total_cache_size);
     
148. 
     
149.     hdr->flags      = NVRAM_FLAGSINFO_VALID;
     
150.     hdr->verify_crc = calc_partition_cache_crc(partition);
     
151. }
     
152. 
     
153. /**
     
154. * @brief  从EEPROM中某个区域取了一定数量的数据，此时判断此EEPROM区域是否是有
     
155. *         效的区域，如果是有效区域则查看是CRC校验是否正确.
     
156. *
     
157. * @param  partition
     
158. * @param  force_offset
     
159. * @param  verify_crc
     
160. * @return -1: 表示读取EEPROM出错.
     
161. *          1：表示是一个新的EEPROM区域
     
162. *          2：表示是一个有效的EEPROM区域，但是CRC校验出错
     
163. * @note   None.
     
164. */
     
165. static int chk_partition_and_verify(struct nvram_partition *partition,
     
166.                                     unsigned long force_offset, uint32_t *verify_crc)
     
167. {
     
168.     uint32_t verify;
     
169.     struct nvram_chip *chip;
     
170.     struct nvram_hdr *hdr;
     
171. 
     
172.     chip = partition->chip;
     
173.     hdr  = get_partition_hdr(partition);
     
174. 
     
175.     // 读取chip对应的此分区并进行有效性标识检查
     
176.     if (chip->read(chip, partition->offset + force_offset, partition->cache_addr,
     
177.                    partition->total_cache_size) != 0) {
     
178.         return -1;
     
179.     }
     
180. 
     
181.     // 如果flags不是一个有效则表示是一个新的EEPROM
     
182.     if (hdr->flags != NVRAM_FLAGSINFO_VALID) {
     
183.         kprintf("find a new chip partition mapping, %s-->%s offset:%u size:%u\n",
     
184.                 chip->name, partition->name, partition->offset, partition->size);
     
185. 
     
186.         // 返回表示chip对应的此分区是一个新的分区
     
187.         return PARTITION_FLAGS_INVALID;
     
188.     } else {
     
189.         // 对CRC再次检验
     
190.         verify = calc_partition_cache_crc(partition);
     
191. 
     
192.         *verify_crc = verify;
     
193. 
     
194.         if (verify != hdr->verify_crc) {
     
195.             // 出现这种原因主要可能是SysParaInfo结构中成员数量有所变化,如程序更改时
     
196.             kprintf("%s verify crc failed, verify:%u, hdr->verify_crc:%u",
     
197.                     partition->name, verify, hdr->verify_crc);
     
198. 
     
199.             return PARTITION_CRC_VERIFY_FAILED;
     
200.         } else {
     
201.             return 0;
     
202.         }
     
203.     }
     
204. }
     
205. 
     
206. /**
     
207. * @brief  None.
     
208. *
     
209. * @param  partition
     
210. * @param  force_offset
     
211. * @return
     
212. * @note   None.
     
213. */
     
214. static int program_partitions(struct nvram_partition *partition,
     
215.                               unsigned long force_offset)
     
216. {
     
217.     int r;
     
218.     struct nvram_chip *chip;
     
219. 
     
220.     chip = partition->chip;
     
221. 
     
222.     r = chip->write(chip, partition->offset + force_offset, partition->cache_addr,
     
223.                     partition->total_cache_size);
     
224. 
     
225.     r = (r == 0) ? 0 : -1;
     
226. 
     
227.     return r;
     
228. }
     
229. 
     
230. /**
     
231. * @brief  None.
     
232. *
     
233. * @param  partition
     
234. * @return
     
235. * @note   None.
     
236. */
     
237. static int init_partitions_cache(struct nvram_partition *partition)
     
238. {
     
239.     uint32_t verify_crc1, verify_crc_bak;
     
240.     int r1, r_bak;
     
241.     unsigned long force_offset;
     
242. 
     
243.     /* --------------------------- 从原始位置读取参数 */
     
244.     /* 读取参数区有效性标识 */
     
245.     force_offset = partition->size >> 1;
     
246. 
     
247.     r_bak = chk_partition_and_verify(partition, force_offset, &verify_crc_bak);
     
248.     r1    = chk_partition_and_verify(partition, 0, &verify_crc1);
     
249. 
     
250.     // 如果两个位置有一个读取失败则返回
     
251.     if ((r1 == -1) || (r_bak == -1)) {
     
252.         copy_default_image(partition);
     
253. 
     
254.         return -1;
     
255.     }
     
256. 
     
257.     /*
     
258.      * 如果首要位置读取成功，则需要判定备份位置是否正确，如果不正确则恢复备份位置
     
259.      * 到首要位置状态
     
260.      */
     
261.     if (r1 == 0) {
     
262.         /* 原始数据区读取有效且数据效验正确 */
     
263.         if ((r_bak) || (verify_crc1 != verify_crc_bak)) {
     
264.             r1 = program_partitions(partition, force_offset);
     
265.         }
     
266. 
     
267.         return r1;
     
268.     } else if (r1 == PARTITION_CRC_VERIFY_FAILED) {
     
269.         /* 原始数据区读取有效但数据校验错误 */
     
270. 
     
271.     } else if (r1 == PARTITION_FLAGS_INVALID) {
     
272.         /* 原始数据区读取有效但是一个新的或是空的区域 */
     
273.     }
     
274. 
     
275.     /* ---------- 程序到此则表明原始的EEPROM区域无法校验通过或是一个新的EEPROM */
     
276. 
     
277.     /* 如果加载出错则需要再次从备份区域加载参数 */
     
278.     r_bak = chk_partition_and_verify(partition, force_offset, &verify_crc_bak);
     
279. 
     
280.     /* 判断备份位置参数是否正确 */
     
281.     if (r_bak == 0) {
     
282.         /* 到此说明最原始的EEPROM区域已无效因此需要更新原始EEPROM区域 */
     
283.         r1 = program_partitions(partition, 0);
     
284. 
     
285.         return ((r1 == 0) ? PARTITION_USE_BACKUP_IMAGE : -1);
     
286.     } else if (r_bak == -1) {
     
287.         kprintf("%s use the default partition image\n", partition->name);
     
288.         copy_default_image(partition);
     
289.     } else if ((r_bak == PARTITION_CRC_VERIFY_FAILED) ||
     
290.                (r_bak == PARTITION_FLAGS_INVALID)) {
     
291. 
     
292.         kprintf("%s use the default partition image\n", partition->name);
     
293. 
     
294.         /*
     
295.          * 如果备份区域也是一个无效的区域或是一个无法校验通过的区域，则此时需要
     
296.          * 使用默认的参数来保证程序的运行
     
297.          */
     
298.         copy_default_image(partition);
     
299. 
     
300.         r_bak = program_partitions(partition, force_offset);
     
301.         r1    = program_partitions(partition, 0);
     
302. 
     
303.         if ((r_bak == 0) && (r1 == 0)) {
     
304.             return PARTITION_USE_DEFAULT_IMAGE;
     
305.         }
     
306.     }
     
307. 
     
308.     return -1;
     
309. }
     
310. 
     
311. /**
     
312. * @brief  None.
     
313. *
     
314. * @param  partition
     
315. * @param  offset_addr
     
316. * @param  buf
     
317. * @param  n_bytes
     
318. * @return None.
     
319. * @note   None.
     
320. */
     
321. static int nvram_raw_write(struct nvram_partition *partition, unsigned long offset_addr,
     
322.                            const char *buf, unsigned long n_bytes)
     
323. {
     
324.     struct nvram_chip *chip;
     
325.     struct nvram_hdr *hdr;
     
326.     uint32_t verify;
     
327.     unsigned long chip_offset;
     
328. 
     
329.     memcpy(partition->cache_addr + offset_addr, buf, n_bytes);
     
330. 
     
331.     // 对CRC再次检验
     
332.     verify = calc_partition_cache_crc(partition);
     
333. 
     
334.     chip   = partition->chip;
     
335.     hdr    = get_partition_hdr(partition);
     
336. 
     
337.     hdr->verify_crc = verify;
     
338. 
     
339.     // 写EEPROM原始位置
     
340.     chip_offset = get_chip_offset(partition, offset_addr);
     
341.     if (chip->write(chip, chip_offset, buf, n_bytes) < 0) {
     
342.         return -1;
     
343.     }
     
344. 
     
345.     chip_offset = get_chip_offset(partition, plat_offsetof(struct nvram_hdr, verify_crc));
     
346.     if (chip->write(chip, chip_offset, (const char *)&verify, sizeof(verify)) < 0) {
     
347.         return -1;
     
348.     }
     
349. 
     
350.     // 更新备份位置
     
351.     chip_offset = get_chip_bak_offset(partition, offset_addr);
     
352.     if (chip->write(chip, chip_offset, buf, n_bytes) < 0) {
     
353.         return -1;
     
354.     }
     
355. 
     
356.     chip_offset = get_chip_bak_offset(partition, plat_offsetof(struct nvram_hdr, verify_crc));
     
357.     if (chip->write(chip, chip_offset, (const char *)&verify, sizeof(verify)) < 0) {
     
358.         return -1;
     
359.     }
     
360. 
     
361.     return 0;
     
362. }
     
363. 
     
364. /**
     
365. * @brief  None.
     
366. *
     
367. * @param  partition
     
368. * @param  offset_addr
     
369. * @param  buf
     
370. * @param  n_bytes
     
371. * @return
     
372. * @note   None.
     
373. */
     
374. static int nvram_raw_read(struct nvram_partition *partition,
     
375.                           unsigned long offset_addr, char *buf,
     
376.                           unsigned long n_bytes)
     
377. {
     
378.     memcpy(buf, partition->cache_addr + offset_addr, n_bytes);
     
379. 
     
380.     return 0;
     
381. }
     
382. 
     
383. /**
     
384. * @brief  None.
     
385. *
     
386. * @param  partition
     
387. * @param  name
     
388. * @return
     
389. * @note   None.
     
390. */
     
391. static struct nvram_param_info *get_param_info(
     
392.                 struct nvram_partition *partition, const char *name) {
     
393.     struct nvram_param_info *tbl;
     
394. 
     
395.     tbl = partition->tbl;
     
396. 
     
397.     for (unsigned int i = 0; i < partition->tbl_size; i++) {
     
398.         if (strcmp(name, tbl->name) == 0)
     
399.             return tbl;
     
400. 
     
401.         tbl++;
     
402.     }
     
403. 
     
404.     return NULL;
     
405. }
     
406. 
     
407. /**
     
408. * @brief  None.
     
409. *
     
410. * @param  part_tbl
     
411. * @param  counter
     
412. * @return
     
413. * @note   None.
     
414. */
     
415. int nvram_init_partitions(struct nvram_partition *part_tbl, unsigned int counter)
     
416. {
     
417.     struct nvram_partition *partition;
     
418. 
     
419.     if (!part_tbl) {
     
420.         return -1;
     
421.     }
     
422. 
     
423.     if (counter < 1) {
     
424.         return -1;
     
425.     }
     
426. 
     
427.     for (unsigned int i = 0; i < counter; i++) {
     
428.         partition = &part_tbl[i];
     
429. 
     
430.         if (chk_partition_info(partition) < 0) {
     
431.             return -1;
     
432.         }
     
433. 
     
434.         if (init_partition_locker(partition)) {
     
435.             return -1;
     
436.         }
     
437. 
     
438.         switch (init_partitions_cache(partition)) {
     
439.         case 0:
     
440.             break;
     
441.         case PARTITION_USE_DEFAULT_IMAGE:
     
442.             break;
     
443.         case PARTITION_USE_BACKUP_IMAGE:
     
444.             break;
     
445.         default:
     
446.             break;
     
447.         }
     
448.     }
     
449. 
     
450.     return 0;
     
451. }
     
452. 
     
453. /**
     
454. * @brief  None.
     
455. *
     
456. * @param  partition
     
457. * @param  name
     
458. * @param  buf
     
459. * @param  size
     
460. * @return
     
461. * @note   None.
     
462. */
     
463. int nvram_set(struct nvram_partition *partition, const char *name, const char *buf, int size)
     
464. {
     
465.     int r = -1;
     
466. 
     
467.     uint32_t param_value;
     
468.     int32_t  param_value_signed;
     
469. 
     
470.     struct nvram_param_info *param_info;
     
471. 
     
472.     if (!partition) {
     
473.         return -1;
     
474.     }
     
475. 
     
476.     if (!name) {
     
477.         return -1;
     
478.     }
     
479. 
     
480.     if (!buf) {
     
481.         return -1;
     
482.     }
     
483. 
     
484.     if (size < 0) {
     
485.         return -1;
     
486.     }
     
487. 
     
488.     if (size == 0) {
     
489.         return 0;
     
490.     }
     
491. 
     
492.     param_info = get_param_info(partition, name);
     
493. 
     
494.     if (param_info == NULL) {
     
495.         return -1;
     
496.     }
     
497. 
     
498.     lock_partition(partition);
     
499. 
     
500.     if ((param_info->type == NVRAM_PARAM_TYPE_UVALUE) ||
     
501.             (param_info->type == NVRAM_PARAM_TYPE_SVALUE)) {
     
502.         switch (param_info->n_byte) {
     
503.         case 1:
     
504.         case 2:
     
505.         case 4:
     
506.             param_value = 0;
     
507.             param_value_signed = 0;
     
508.             if (param_info->type == NVRAM_PARAM_TYPE_UVALUE) {
     
509.                 param_value = (uint32_t)strtoul(buf, 0, 0);
     
510.                 r = nvram_raw_write(partition, param_info->offset,
     
511.                                     (char *)&param_value, param_info->n_byte);
     
512.             } else {
     
513.                 param_value_signed = (int32_t)strtol(buf, 0, 0);
     
514.                 r = nvram_raw_write(partition, param_info->offset,
     
515.                                     (char *)&param_value_signed, param_info->n_byte);
     
516.             }
     
517.             break;
     
518. 
     
519.         default:
     
520.             break;
     
521.         }
     
522.     } else if (param_info->type == NVRAM_PARAM_TYPE_STRING) {
     
523. 
     
524.         unsigned int value_len = DEF_MIN(size, param_info->n_byte);
     
525. 
     
526.         r = nvram_raw_write(partition, param_info->offset, buf, value_len);
     
527.     }
     
528. 
     
529.     unlock_partition(partition);
     
530. 
     
531.     return r;
     
532. }
     
533. 
     
534. /**
     
535. * @brief  None.
     
536. *
     
537. * @param  partition
     
538. * @param  name
     
539. * @param  buf
     
540. * @param  size
     
541. * @return
     
542. * @note   None.
     
543. */
     
544. int nvram_get(struct nvram_partition *partition, const char *name, char *buf, int size)
     
545. {
     
546.     int r = -1;
     
547. 
     
548.     uint32_t param_value;
     
549.     int32_t  param_value_signed;
     
550. 
     
551.     struct nvram_param_info *param_info;
     
552. 
     
553.     if (!partition) {
     
554.         return -1;
     
555.     }
     
556. 
     
557.     if (!name) {
     
558.         return -1;
     
559.     }
     
560. 
     
561.     if (!buf) {
     
562.         return -1;
     
563.     }
     
564. 
     
565.     if (size < 0) {
     
566.         return -1;
     
567.     }
     
568. 
     
569.     if (size == 0) {
     
570.         return 0;
     
571.     }
     
572. 
     
573.     param_info = get_param_info(partition, name);
     
574. 
     
575.     if (param_info == NULL) {
     
576.         return -1;
     
577.     }
     
578. 
     
579.     lock_partition(partition);
     
580. 
     
581.     if ((param_info->type == NVRAM_PARAM_TYPE_UVALUE) ||
     
582.             (param_info->type == NVRAM_PARAM_TYPE_SVALUE)) {
     
583.         switch (param_info->n_byte) {
     
584.         case 1:
     
585.         case 2:
     
586.         case 4:
     
587.             param_value = 0;
     
588.             param_value_signed = 0;
     
589.             if (param_info->type == NVRAM_PARAM_TYPE_UVALUE) {
     
590.                 r = nvram_raw_read(partition, param_info->offset,
     
591.                                    (char *)&param_value, param_info->n_byte);
     
592. 
     
593.                 ksnprintf(buf, size, "%u", param_value);
     
594.             } else {
     
595.                 r = nvram_raw_read(partition, param_info->offset,
     
596.                                    (char *)&param_value_signed, param_info->n_byte);
     
597. 
     
598.                 ksnprintf(buf, size, "%s", param_value_signed);
     
599.             }
     
600.             break;
     
601. 
     
602.         default:
     
603.             break;
     
604.         }
     
605.     } else if (param_info->type == NVRAM_PARAM_TYPE_STRING) {
     
606. 
     
607.         unsigned int value_len = DEF_MIN(size, param_info->n_byte);
     
608. 
     
609.         r = nvram_raw_read(partition, param_info->offset, buf, value_len);
     
610.     }
     
611. 
     
612.     unlock_partition(partition);
     
613. 
     
614.     return r;
     
615. }
     
616. 
     
617. /**
     
618. * @brief  None.
     
619. *
     
620. * @param  partition
     
621. * @param  name
     
622. * @param  value
     
623. * @return
     
624. * @note   None.
     
625. */
     
626. int nvram_set_ulong(struct nvram_partition *partition, const char *name, unsigned long value)
     
627. {
     
628.     struct nvram_param_info *param_info;
     
629.     int r = -1;
     
630. 
     
631.     if (!partition) {
     
632.         return -1;
     
633.     }
     
634. 
     
635.     if (!name) {
     
636.         return -1;
     
637.     }
     
638. 
     
639.     param_info = get_param_info(partition, name);
     
640. 
     
641.     if (param_info == NULL) {
     
642.         return -1;
     
643.     }
     
644. 
     
645.     lock_partition(partition);
     
646. 
     
647.     if ((param_info->type == NVRAM_PARAM_TYPE_UVALUE) ||
     
648.             (param_info->type == NVRAM_PARAM_TYPE_SVALUE)) {
     
649.         switch (param_info->n_byte) {
     
650.         case 1:
     
651.         case 2:
     
652.         case 4:
     
653.             r = nvram_raw_write(partition, param_info->offset,
     
654.                                 (char *)&value, param_info->n_byte);
     
655.             break;
     
656. 
     
657.         default:
     
658.             break;
     
659.         }
     
660.     }
     
661. 
     
662.     unlock_partition(partition);
     
663. 
     
664.     return r;
     
665. }
     
666. 
     
667. /**
     
668. * @brief  None.
     
669. *
     
670. * @param  partition
     
671. * @param  name
     
672. * @param  value
     
673. * @return
     
674. * @note   None.
     
675. */
     
676. int nvram_get_ulong(struct nvram_partition *partition,
     
677.                     const char *name, unsigned long *value)
     
678. {
     
679.     int r = -1;
     
680. 
     
681.     unsigned long param_value;
     
682. 
     
683.     struct nvram_param_info *param_info;
     
684. 
     
685.     if (!partition) {
     
686.         return -1;
     
687.     }
     
688. 
     
689.     if (!name) {
     
690.         return -1;
     
691.     }
     
692. 
     
693.     if (!value) {
     
694.         return -1;
     
695.     }
     
696. 
     
697.     param_info = get_param_info(partition, name);
     
698. 
     
699.     if (param_info == NULL) {
     
700.         return -1;
     
701.     }
     
702. 
     
703.     lock_partition(partition);
     
704. 
     
705.     if ((param_info->type == NVRAM_PARAM_TYPE_UVALUE) ||
     
706.             (param_info->type == NVRAM_PARAM_TYPE_SVALUE)) {
     
707.         switch (param_info->n_byte) {
     
708.         case 1:
     
709.         case 2:
     
710.         case 4:
     
711.             param_value = 0;
     
712. 
     
713.             r = nvram_raw_read(partition, param_info->offset,
     
714.                                (char *)&param_value, param_info->n_byte);
     
715. 
     
716.             if (r == 0) {
     
717.                 *value = (unsigned long)param_value;
     
718.             }
     
719.             break;
     
720. 
     
721.         default:
     
722.             break;
     
723.         }
     
724.     }
     
725. 
     
726.     unlock_partition(partition);
     
727. 
     
728.     return r;
     
729. }

复制代码

electrlife

eye 发表于 2014-5-16 21:21
/// xxx.h

struct nvram_sysparam {

嗯确实是一个好方法，但是我的本意不是要使用这种方式来访问struct nvram_sysparam里的变量，
而是通过下面的int nvram_set(struct nvram_partition *partition, const char *name, const char *buf, int size);函数接口
来访问struct nvram_sysparam里的变量，而变量的大小与偏移量nvram_set函数处理，用户只关心参数的名字即可，也不需
要关心类型等，全部转化成ASCII流的方式。这样在效率上有所下降，但是通用性和可利用性比较好些！

Gorgon_Meducer

electrlife 发表于 2014-5-17 11:03
嗯确实是一个好方法，但是我的本意不是要使用这种方式来访问struct nvram_sysparam里的变量，
而是通过下 ...

用ASC不是一个好方法，使用它只是你们团队的历史遗留问题。我这么说，就说明
他具有争议性，有争议性的内容请标明具有争议性，但不可作为原则直接提出，会
有误导经验不足的程序员的可能。
你这一篇着重介绍的是存储器抽象层（MAL），写得很好，但我发现你的接口都有
一个违反嵌入式系统初衷的“倾向”——通用。嵌入式系统一定要专用，反映到接口
设计上也必须专用，以满足裁剪，成本和功能的平衡。嵌入式系统的确可以使用通用
计算机系统的知识，但必须要做一定的吸收和转化。具体来说，就是嵌入式系统不可
追求通用，只能追求在“严格定义的应用环境，功能需求下”，在不增加或只增加少量
成本下“尽可能多的获得通用性”。所以，这里的通用是限制范围内的最大化。

做出通用不难，但要做出“好用量刚好”的嵌入式接口，就一定要在讨论前明确的声明
应用环境，需求之类。比如，你这里提出的接口，你要明确的说出其应用的平台大约
是什么级别的MCU，拥有多大的资源（flash，sram）这么设计接口是为了满足怎样
的应用需求。

嵌入式系统，是面向应用，高度裁剪的“专用计算机系统” 。请大家从一开始就意识到
这里的专用。然后再学会定义范围后的讨论。很实在的，没有范围，总有人站出来
指出你的资源，效率有问题，不明真相的看客也容易被吓到。

zhiyuanzhitian

Dioxide louzhu,xuexi le

electrlife

Gorgon_Meducer 发表于 2014-5-17 11:47
用ASC不是一个好方法，使用它只是你们团队的历史遗留问题。我这么说，就说明
他具有争议性，有争议性的内 ...

     呵呵，班竹说的确实严谨很多！这里的通用是针对非易失性存储器的接口提出的，在平时的项目中非易失性存储器使用比较多
也是实际需要我去实现一种统一的管理方式，这里之所以使用的从字符串流到到BIN流转换也是经过折中的一种方案，
后续的文章会提到关于后续程序的升级的问题，如果升级程序涉及到EEPROM中参数的更新与变化，那原始EEPROM中一些
参数数据必须能够保存与恢复，而如果新的程序中struct nvram_sysparam的内容出现变化，那么将无法通过BIN流的形式进行
恢复与管理。其实ASCII的流的方式就我个人来说，我觉得确实是可以简化你的程序设计并提高通用性，但确实性能方面有所
损失。这里我给出一个项目中我遇到的一个真实的ASCII的案例（这个案例本应该在上述文章中给出的）：
    在我去年的一个项目中需要对设备每次运行的一些关键数据进行记录，以便后期查阅，我想这种历史记录的功能一般大家也
会用到吧，当初我的做法就是如下所示，假设结构体中是需要记录的数据
struct history_data {
        int data1;
        int data2;
        int data3;
        int data4;
};
一般都是直接eep_write(..., sizeof(struct history_data));也即直接存储为BIN格式的，但当某天领导告诉我需要为机器增加一个新的数据进行保存，
其实这对新程序实现很简单，但是更新程序后，以前的记录就全部丢失了，因为你不能再通过eep_read(..., sizeof(struct history_data))读取了，
而你如果存储时是以ASCII的方式，那么这个问题就很好处理了，比如你可以存储"data1=1\0data2=2\0data3=3\0data4=4\0\0"。不管你的struct
结构如何改变，你都可以通过ASCII的方式解析得到具的数据。
     因此我把ASCII作为一个通用性原则提出，因为实际的项目中类似上面的案例很多！当然你确实是需要去评估你的MCU资源与实际项目需求！

      对于EEPROM的管理，其实还有另一种更加通用实现方式，但需要一定量的内存与复杂的算法，如果感兴趣可以去看下u-boot的非易失性存储器的管理方式，
这种是完全ASCII的方式，其EEPROM中的参数的数量与大小可以在程序运行时动态增加与减少，这种方式我也实现了，现无奈正如版主所说，
它所需的内存与算法不是一般单片机所能接受的，如果只是为了管理几个参数那就不合适了！

huike

第一篇觉得很不错。第二篇就有些太过于个人应用了。并不适合大多数人的思路。其实简单点讲，要用到如些复杂的存储应用，就应该上FS了。而不能再继续搞这个祼体了。

Gorgon_Meducer

electrlife 发表于 2014-5-17 15:33
呵呵，班竹说的确实严谨很多！这里的通用是针对非易失性存储器的接口提出的，在平时的项目中非易失 ...

你举的例子实际上是面向对象数据处理，用扩展替代修改的典型例子。
一般情况下，如果预见到数据类型会发生扩展，应该在结构体第一个位置
留下一个位置，比如ID，或者是接口说明符之类的来表征当前数据由哪个
版本的程序来处理。这样，利用多态技术（使用类型解析和分发），让正确
的代码来处理这段数据。一旦数据被解析后，下次就统一用新的数据格式来
保存了。从面向对象技术来说，这种方式更灵活，更专注，扩展性也更强。

字符串的确更灵活，所以，大型系统往往使用XML来存储数据。但，那是
资源丰富环境下的玩法。我猜你经常处理的平台是ARM9以上的。少数M3以上的
环境也可以这么玩。但怎么说呢，看你的平台了。如果你的平台效应很强，
从平台继承一些通用的做法不失为快速开发的捷径。但如果是我，我一定会
选择在平台间增加一个转换适配来处理通用到专用的过度。把更多的通用性
放在资源丰富的一边，这是诀窍，也是指导原则。

eye

再提一个可以讨论，也是我遇到的实际问题。

使用一个struct来组织EEPROM数据：
     好处是地址由编译器自动分配了，限制只在末尾添加数据项可以做到升级兼容。
     不好的地方就是各个模块用到的数据都耦合到一起了。

另外一个方案就是把数据都定义到同一个section，让连接器来分配地址。
类似于

1. 
   
2. #pragma section="EEPROM"
   
3. static const char SN[16] = "SN:0000001";
   

复制代码

实际SN的EEPROM地址只需要相对__section_begin("EEPROM")偏移就好了。
这个方案：
     好处是地址由编译器自动分配，低耦合。
     不好就是升级以后向下兼容麻烦，不好做数据继承。

最终我们用的还是第一个方案，牺牲了优雅吧。

10xjzheng

目前水平还是看不懂

foxpro2005

eye 发表于 2014-5-19 11:36
再提一个可以讨论，也是我遇到的实际问题。

使用一个struct来组织EEPROM数据：

呵呵， 我平时也是这么做的，使用struct来组织EEPROM的数据。

我是有一个专门负责参数的模块： 对于参数的维护比较方便。
1） 它负责来整合其它模块使用的存储参数；
2） 完成参数的合法性检查，校验等；
3） 默认的配置参数， 用于初始化EEPROM， 以及参数检验失败（出错）后的恢复的默认数据。（可以确保设备的正常运行）

myj

非常有用，谢谢楼主

kingqb

分析得很透彻，很有感触

LJW

看了两三遍，还是没明白当中的机制，再多看几遍试试

黄晨0410

我目前的水平，看不懂  大家都说好，但我去看不懂

黄晨0410

electrlife 发表于 2014-5-17 15:33
呵呵，班竹说的确实严谨很多！这里的通用是针对非易失性存储器的接口提出的，在平时的项目中非易失 ...

为什么说用 ASCII 的方法就可以解决 当history_data结构体内增加元素后，仍可用  eep_read(....,sizeof(struc history_data))读取  呢 ？？？

zyw19987

electrlife 发表于 2014-5-17 15:33
呵呵，班竹说的确实严谨很多！这里的通用是针对非易失性存储器的接口提出的，在平时的项目中非易失 ...

很荣幸能看到这么好的帖子。
请问楼主你以前的门题是如何解决的呢?现在应该有比较好的感悟了吧，希望能分亨一下。
http://www.amobbs.com/thread-5479799-1-1.html

云边落叶

mark,感谢楼主！！！！！！！！！

mvpgpz

好帖，解答了不少以前的疑惑。谢谢楼主

sxgtc

一直在受用中~经典~