1. 首先 检查RTC电池是否装载，没电池的话，设备掉电也保存不了数据。
 
  备份寄存器就是普通的RAM，需要配合外接电池使用，如果没有电池，就不能掉电保持数据。
  因为是普通RAM，所以不存在写入次数的问题，理论上是无限次的。
 
 其次在RCC_Configuration(); 中配置备份寄存器的如下：
 
 /* Enable PWR(电源控制） and BKP clock */
     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
 /* Enable write access to Backup domain */
     PWR_BackupAccessCmd(ENABLE);
 /* Clear Tamper pin Event(TE) pending flag */
     BKP_ClearFlag();
 
 
 2. 然后就可以开始读写功能了。
 
 void WriteBKP(u16 Data,u8 DRNumber)       // 还可加入一些加密算法;DRNumber （1-9）
 {
     switch(DRNumber)
 
     {  
         case 0x01: 
                         BKP_WriteBackupRegister(BKP_DR1,Data); 
                 break;
 
         case 0x02: 
                         BKP_WriteBackupRegister(BKP_DR2,Data);                       
                 break;
 
         case 0x03:               
                         BKP_WriteBackupRegister(BKP_DR3,Data);                         
                 break;
 
         case 0x04:                       
                         BKP_WriteBackupRegister(BKP_DR4,Data); 
                 break;
 
         case 0x05:                 
                 BKP_WriteBackupRegister(BKP_DR5,Data);                 
                 break;
 
         case 0x06:               
                  BKP_WriteBackupRegister(BKP_DR6,Data); 
                  
                  break;
 
         case 0x07:                
                 BKP_WriteBackupRegister(BKP_DR7,Data);                
                 break;
 
         case 0x08:                
                 BKP_WriteBackupRegister(BKP_DR8,Data); 
                 
                 break;
 
         case 0x09:                
                 BKP_WriteBackupRegister(BKP_DR9,Data); 
                 
                 break;
 
                  case 0x10:                 
                 BKP_WriteBackupRegister(BKP_DR10,Data); 
                 
                 break;
 
         default:    
 
                         BKP_WriteBackupRegister(BKP_DR1,Data);
 
     }
     BKP_WriteBackupRegister(BKP_DR10,CHECK_CODE);
 
 }
 
 u8 CheckBKP(void)
 
 {
     if( BKP_ReadBackupRegister(BKP_DR1) == 0x89)   // 如果此位数据丢失，则BPK数据丢失
 
         return 1;
     else
         return 0;
 }
 
 3.调试总结：
 
 可以在IAR或者keil的watch 中查看值是否写入，输入BKP_DR1，可以查看BKP_DR1中的数据是否写入正确，其他的备份寄存器类似操作。
 
 另外在程序中有RTC程序的话，要注意配置顺序，因为RTC也对备份寄存器操作。我就是程序中有RTC程序，所以写入的数据老是被清零（RTC程序会初始化备份寄存器中的数据），浪费了点时间才找到原因所在。

  在配置i2c从设备寄存器时往往需要修改驱动中的初始化函数来修改寄存器的值，这样往往需要重新编译内核，其实可以使用i2c驱动提供给应用层的接口函数ioctl来在命令行修改寄存器，只需要编写一个类似i2c测试程序的程序文件，使用int main(int argc, char **argv) 来向程序传递参数即可实时读写从设备的寄存器，工作队列(workqueue)可以实现多个寄存器的取值。
 

#include <stdio.h> 
#include <linux/types.h> 
#include <fcntl.h> 
#include <unistd.h> 
#include <stdlib.h> 
#include <sys/types.h> 
#include <sys/ioctl.h> 
#include <errno.h> 
#include <assert.h> 
#include <string.h> 
#include <linux/i2c.h> 
#include <linux/i2c-dev.h> 

#define MAX_I2C_MSG          2 

#define I2C_RETRIES       0x0701 
#define I2C_TIMEOUT       0x0702 
#define I2C_RDWR          0x0707 
#define ADV7180_REG_NUM      253     /*连续读的寄存器个数*/
#define ADV7180_REG_BASE_ADDR   0   /*要连续读的第一个寄存器的地址，此处从0x00开始连续读253个寄存器值*/


/*此函数作用是把从命令行输入的数字字符转换为十六进制数，即寄存器地址或值*/
int strtol_dzb(unsigned char *ps,int flag)
{
    int i=10;    
    int r=0; 
    char *pc = ps;


    if(NULL==ps )  return -1;

    while(*pc != '\0')
    {
       if((*pc >= 'a' && *pc <= 'f') || 
          (*pc >= 'A' && *pc <= 'F') || 
          (*pc == 'x' || *pc == 'X') )
       {   
           i=16;          
       }
       else if( *pc < '0' || *pc > '9')
       {
           return -1;
       }
       pc++;  
    }  

    if(flag!=0)  i=flag;

    pc = ps;

    while(*pc != '\0')
    {
       r *= i;

       if( *pc>='a' && *pc <= 'f')
       {   
           r += (*pc-'a')+10;
       }
       else if( *pc>='A' && *pc <= 'F')
       {   
           r += (*pc-'A')+10;
       }
       else if( *pc>='0' && *pc <= '9')
       {   
           r += (*pc-'0');
       }
       
       pc++;  
    }    
    return r;
}


/* 主函数，3种情况，一个参数时读出253个值；三个参数时为“./test -r 0x00”,读某个寄存器；四个参数时为“./test -w 0x00 0x11”,写寄存器00值为11。*/
int main(int argc, char **argv) 
{ 
    struct i2c_rdwr_ioctl_data work_queue; 
    unsigned char idx; 
    unsigned char mode=1;//1--read, 0--w; 
    unsigned int fd;     
    unsigned short slave_address=0x68;
    unsigned short reg_address =ADV7180_REG_BASE_ADDR;//0x2c; 
    unsigned char val[256]={0};
    unsigned char data_len=ADV7180_REG_NUM;
    unsigned char data=0;
    int ret,tmp; 

    fd = open("/dev/i2c-1",O_RDWR); 
    work_queue.nmsgs = MAX_I2C_MSG; /*  消息数量  */  
    
    work_queue.msgs  =  (struct  i2c_msg*)malloc(work_queue.nmsgs*sizeof(struct i2c_msg)); 
    if (!work_queue.msgs) 
    { 
      	printf("Memory alloc error\n"); 
      	close(fd); 
      	return 0; 
    } 

    //printf("argc =%d \n",argc);
    if(argc==1) // dump 7180
    {
        idx = reg_address;
        val[idx]=idx;
      	(work_queue.msgs[0]).len = 1; 
        //(work_queue.msgs[0]).flags = 0;//I2C_M_WR;
      	(work_queue.msgs[0]).addr = slave_address; 
      	(work_queue.msgs[0]).buf = &val[idx]; 

        (work_queue.msgs[1]).len = data_len; 
        (work_queue.msgs[1]).flags = 1;//I2C_M_RD; 
      	(work_queue.msgs[1]).addr = slave_address; 
      	(work_queue.msgs[1]).buf  = &val[idx];         
   
	    ioctl(fd, I2C_TIMEOUT, 2); /*  设置超时  */ 
	    ioctl(fd, I2C_RETRIES, 1); /*  设置重试次数  */

	    ret = ioctl(fd, I2C_RDWR, (unsigned long) &work_queue); 

	    if (ret < 0) 
	    { 
	      	printf("Error  during  I2C_RDWR  ioctl  with  error  code:  %d\n",  ret); 
	    } 
	    else
	    {
               
		printf("\n-----------------ADV7180 Reg-Test---------------------\n");
                printf(  "addr:  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f \n");
                printf(  "------------------------------------------------------");
	    
		for(idx = 0; idx < ADV7180_REG_NUM; idx++) 
		{ 
		    if(idx%16==0) printf("\n %02x: ", idx);   
		    printf(" %02x", val[idx]);
		}
                printf("\n-----------------------END----------------------------\n"); 
                           
	    }            
      }    
      else if(argc==2|| argc > 4)
      {
 	    printf("Usage:    %s [[-r regAddr] | [-w regAddr byteData]]\n", argv[0]);
            printf("              -r regAddr     read a byte from register--regAddr of adv7180\n");
            printf("              -w regAddr  data   write a byte data to register--regAddr of adv7180\n");
     }     
     else 
     {
          if(strstr(argv[1],"-r") ) // read a byte only
          {     
                if(-1 == (tmp=(unsigned short)strtol_dzb(argv[2],16)) )
                {
                     printf(" Invalid reg_addr: %s ",argv[2]);
                     close(fd);
                     return -1;
                }    
       
	    	reg_address=(unsigned short)tmp;
                printf("mode: read  reg_addr:  %3d (%02x) \n", reg_address, reg_address);
                
	    	
	    	val[0]=(unsigned char)reg_address;
      	    	(work_queue.msgs[0]).len = 1; 	    	
      	    	(work_queue.msgs[0]).addr = slave_address; 
      	    	(work_queue.msgs[0]).buf = &val[0]; 

	    	(work_queue.msgs[1]).len = data_len; 
	    	(work_queue.msgs[1]).flags = 1;//I2C_M_RD; 
      	    	(work_queue.msgs[1]).addr = slave_address; 
      	    	(work_queue.msgs[1]).buf  = &val[0];         
   	     	work_queue.nmsgs=2;

	    	ioctl(fd, I2C_TIMEOUT, 2); /*  璁剧疆瓒呮椂  */ 
	    	ioctl(fd, I2C_RETRIES, 1); /*  璁剧疆閲嶈瘯娆℃暟  */ 

	    	ret = ioctl(fd, I2C_RDWR, (unsigned long) &work_queue); 

	    	if (ret < 0) 
	    	{ 
	      		printf("Error  during  I2C_RDWR  ioctl  with  error  code:  %d\n",  ret); 
	   	} 
                else 
                {
			printf("Read: Reg--%02x   Data--%02x  \n", reg_address, val[0]);
                }
          }
          else if( strstr(argv[1],"-w") ) // write a byte only
          {
            	   
                if(-1 == (tmp=(unsigned short)strtol_dzb(argv[2],16)) )
                {
                     printf(" Invalid reg_addr: %s ",argv[2]);
                     close(fd);
                     return -1;
                } 

	    	reg_address = (unsigned short)tmp;

            	if(-1 == (tmp=(unsigned short)strtol_dzb(argv[3],16)) )
                {
                     printf(" Invalid data: %s ",argv[3]);
                     close(fd);
                     return -1;
                } 
	    	data = (unsigned char)tmp;

            	printf("mode: write  reg_addr:  0x%02x   data: %x  \n", reg_address, data);
                        	
    		val[0]=(unsigned char)reg_address;
            	val[1]=data;

  	    	(work_queue.msgs[0]).len = 2; 
    		(work_queue.msgs[0]).flags = 0;//I2C_M_WR;
  	    	(work_queue.msgs[0]).addr = slave_address; 
  	    	(work_queue.msgs[0]).buf = &val[0]; 		          
        	work_queue.nmsgs=1;

		ioctl(fd, I2C_TIMEOUT, 2); /*  璁剧疆瓒呮椂  */ 
		ioctl(fd, I2C_RETRIES, 1); /*  璁剧疆閲嶈瘯娆℃暟  */ 

		ret = ioctl(fd, I2C_RDWR, (unsigned long) &work_queue); 

		if (ret < 0) 
		{ 
		    printf("Error  during  I2C_RDWR  ioctl  with  error  code:  %d\n",  ret); 
		} 
#if 0
        	else 
	        {
	                (work_queue.msgs[0]).len = 1; 
		    	(work_queue.msgs[0]).flags = 0;//I2C_M_WR;
	      	        (work_queue.msgs[0]).addr = slave_address; 
	      	        (work_queue.msgs[0]).buf = &val[0]; 

		    	(work_queue.msgs[1]).len = data_len; 
		    	(work_queue.msgs[1]).flags = 1;//I2C_M_RD; 
	      	        (work_queue.msgs[1]).addr = slave_address; 
	                val[idx]=0;
	      	        (work_queue.msgs[1]).buf  = &val[0];         
	   	     	work_queue.nmsgs=2;

		    	ioctl(fd, I2C_TIMEOUT, 2); /*  璁剧疆瓒呮椂  */ 
		    	ioctl(fd, I2C_RETRIES, 1); /*  璁剧疆閲嶈瘯娆℃暟  */ 
		    	ret = ioctl(fd, I2C_RDWR, (unsigned long) &work_queue);
				
			if (ret < 0) 
		        { 
		      	    printf("Error  during  I2C_RDWR  ioctl  with  error  code:  %d\n",  ret); 
		        } 
	            	else
		    	{
			    printf("Write: reg--%02x   w-data--%02x  r-data--%02x \n", reg_address,data,val[0]);
	            	}
	        }
#endif
      	} 
    }      

    close(fd); 
    return ; 
} 


 

 
 

 

背景
 

寄存器中按位定义数据的方法存在于很多厂家设备的MODBUS数据协议中。区别于线圈状态（RW）和离散输入（RO）,寄存器中通过定义组合位数据，更有利于高效传输状态信息和设置开关量。
 
由于位数据被定义在寄存器中，其读写操作必须遵循寄存器的读写流程。RO位数据要求从机以拼装的方式同时上报相关的位数据，而在向RW位数据写入位数据时，主机需要携带其他位数据的当前值一并下发至从机。这些处理过程相比较线圈状态（RW）和离散输入（RO）的读写操作更加复杂。
 
目前普通的MODBUS调试调测软件都不具备这种情形下的主从机模拟能力。
 
MThings提供的能力
 

 
读写寄存器位数据(BIT)，同时支持输入寄存器和保持寄存器。
 
 
不仅支持单BIT数据，而且支持寄存器范围内的多BIT定义。
 
 
支持BIT数据定义跨寄存器。
 
 
支持位数据仿真模拟。
 
 
支持位数据曲线绘制。
 
寄存器位数据的设计约束
 

 
寄存器位数据的传输类型必须为无符号整形。
 
 
寄存器位数据的呈现类型必须为十进制整形。
 
 
位数据的位数 ＜ 寄存器个数*16。
 
 
基于寄存器所配置的字节序或字序，位序的编号从0开始，0代表最低位。
 
数据配置方法
 

寄存器数据中增加“位偏移”、“位数”配置项。
 
位偏移即为起始位号，默认为0；位数代表该数据所占用BIT数据，默认为寄存器个数*16。
 
数据配置默认状态下非启用位数据，需要用户编辑指定。
 
示例：
 
 
寄存器位数据可以解决什么问题
 

MThings提供的位数据读写方法可以直观的将寄存器位数据拆分为独立数据进行操作，工具软件保证了各项操作的准确性。
将寄存器位数据同等视为一项协议数据，提供对等的服务支持，包含曲线、仿真模拟等。
独立的位数据操作不影响轮询性能，MThings后台智能组合位数据，不会额外增加交互次数。

通用寄存器：是程序执行代码最最常用，也是最最基础的寄存器，程序在执行过程中，绝大部分时间都是在操作这些寄存器来实现指令的功能。
 
既然是通用的，那么这些寄存器就没有特殊的用途，应用程序爱怎么使用怎么使用，只要遵循一个既定的潜规则即可。
 
 
 
eax: 通常用来执行加法，函数调用的返回值一般也放在这里面
 
 
ebx: 数据存取
 
 
ecx: 通常用来作为计数器，比如for循环 .//C++中this指针也是通过ecx来传递的，可以通过反汇编来验证。
 
 
edx: 读写I/O端口时，edx用来存放端口号
 
 
esp: 栈顶指针，指向栈的顶部
 
 
ebp: 栈底指针，指向栈的底部，通常用ebp+偏移量的形式来定位函数存放在栈中的局部变量
 
 
esi: 字符串操作时，用于存放数据源的地址
 
 
edi: 字符串操作时，用于存放目的地址的，和esi两个经常搭配一起使用，执行字符串的复制等操作
 
 
在x64架构中，上面的通用寄存器都扩展成为64位版本，名字也进行了升级。上面的名字仍然是可以使用的，相当于访问64位寄存器的低32位。
 
 
 
rax rbx rcx rdx rsp rbp rsi rdi
 
 
x64架构还增加了8个新的通用寄存器：
 
 
 
r8,r9,r10,r11,r12,r13,r14,r15
 
 
与32位cpu比起来，x64的寄存器资源非常丰富了，所以参数传递绝大多数都是用寄存器来传了。寄存器传参的好处是速度快，减少了对内存的读写次数。
 
当然，具体使用栈还是用寄存器传参数，这个不是编程语言决定的，而是编译器在编译生成CPU指令时决定的，如果编译器非要在x64架构CPU上使用线程栈来传参那也不是不行，这个对高级语言是无感知的。