devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32调试MIPI RFFE协议_stm32 mipi

作者：你好赵伟 | 2024-06-11 18:48:29

赞

踩

stm32 mipi

目录

一、前言

二、RFFE总线

三、协议时序

四、器件状态

五、更改USID

六、程序代码

七、参考资料

一、前言

前阵子手里有几个天线调谐器芯片，1.5x1mm的BGA封装非常小，通信控制协议是MIPI RFFE协议，这个协议网上资料比较少，搜了一下搜到了一个标准的MIPI协议文档，里面各种控制时序和介绍都写的非常详细了，其实就和I2C这类的协议差不多吧，然后在CSDN上又找到了一个STM32用GPIO模拟MIPI RFFE协议的文档资料作参考，稍微改了改，调试的时候遇到了一些问题，然后用逻辑分析仪抓了抓波形改了改代码，然后调试成功了，本文进行调试总结。

 

二、RFFE总线

RFFE总线定义如下：

https://files.sekorm.com/opt/fileStore/portal/ecnew/editor/new/20160620/1466401433395087932th.jpg

 

VIO：RFFE接口的基准电压，也可以作为复位和使能输入。一个施加到VIO 信号的逻辑低电平可以将RFFE接口关断。

SCLK：RFFE 总线时钟输入。通常被连接至RF 或基带IC 上的RFFE 主机。当未施加VIO 时，SCLK 必须为低电平。时钟频率范围为32KHz到26MHz。

SDATA：RFFE 总线数据输入/输出。通常被连接至RF 或基带IC 上的RFFE 主机。当未施加VIO 时，SCLK 必须为低电平。

MIPI RFFE协议和I2C协议真的共性很多，都是一条数据线（SDATA）和一条时钟线（SCLK），然后所有的从设备都通过这两条线挂接到总线上，所有的从设备都可以设置独立的从设备地址，Master可以通过从设备地址来单独控制多个从设备中的单个设备，RFFE总线高电平为1.2到1.8V，VIO供电也是1.2到1.8V，注意不要用3.3V单片机IO直接驱动，要接个电平转换芯片。RFFE设备连接框图如下：

 

三、协议时序

时序操作基本上可以归为两类操作，寄存器写和寄存器读，其中寄存器写又分为寄存器0写入、普通寄存器写入和扩展寄存器写入；读可以分为普通寄存器读和扩展寄存器读。从机寄存器寻址如下。

https://files.sekorm.com/opt/fileStore/portal/ecnew/editor/new/20160620/1466401649058019994th.jpg

写寄存器命令分好几种，区别就是可以访问的寄存器地址区间不一样，我手头上这个IC的有用数据都是定义在寄存器0到31上的，之后的地址没定义，所以用不到扩展寄存器写命令。不管是哪种操作，都可以归类为：SSC头+命令帧+数据帧+停止帧。

https://files.sekorm.com/opt/fileStore/portal/ecnew/editor/new/20160620/1466401671314017211th.jpg

1、基本命令帧

（1）SSC（Sequence Start Condition）

 

 SSC具体时序是SCLK为低电平时，SDATA由0变为两个周期的1，然后变为0。SSC相当于是启动信号，每次命令操作都需要先发送该时序。

（2）命令帧

命令帧前4bit为从机地址，接下来是8bit的命令+1bit的奇校验位（对前12bit数据进行奇校验），

（3）数据帧

8bit的数据+1bit的奇校验。

（4）Bus Park帧

最后在SCLK的一个下降沿SDATA保持一个以上周期的0电平来使总线挂起也就是Bus park。

 

2、寄存器写操作

（1）寄存器0写入

SA0到SA3是从机地址，一般和器件的4位USID值是一致的，寄存器0写入命令的命令帧前8bit的最高位D7是固定为1的，剩下的D0到D6是写入到寄存器0的数据，实际上也就只能修改寄存器0的D0到D6的数据。

（2）非0寄存器写入

命令帧的前3位D7，D6，D5固定为0,1,0，剩下的5位表示寄存器地址，实际上能够寻址的寄存器范围只有0到31，命令帧接下来是数据帧，D0到D7是要写入到相应寄存器的数据。

（3）扩展寄存器写入

命令帧的前4位固定为全0，只剩下BC0~BC3是可以自己填的，这4位表示要写入多少个字节的数据，0表示写一个字节，0xF表示写16个字节，其实一个寄存器只能写1个字节，多写的字节会根据当前寄存器的地址开始向后写入到后面的寄存器中。数据帧那里的8位用来填写寄存器的地址，之后的很多个帧根据BC0~BC3的值追加多个要写入的字节数据。

3、寄存器读操作

（1）寄存器读

读寄存器跟写寄存器一样的套路，先给4位从机地址，然后因为是普通读，命令帧的高三位定死了是0,1,1，剩下的5位可以自己填，实际只能寻址0到31这些寄存器，然后后面接8位的数据读取操作，这里读取操作的时候主机要把SDATA设为下拉模式，即默认电平为低电平，然后从机输出数据的话如果是1会把SDATA拉高，8位寄存器数据之后是1位寄校验（对前面8位数据校验），注意编程的时候还是要判断下器件给的奇校验位P，看下是不是校验能够通过，否则读到的数据是错的。

 

（2）扩展寄存器读

BC0到BC3表示读取的字节数目，为0时表示都1个字节，为0xF时表示读16个字节，读超过1个字节会返回当前寄存器地址往后的寄存器地址的内容，和扩展寄存器写套路一样的。

 

四、器件状态

以下是器件状态切换图：

RFFE的器件有几种状态可以切换，分别为STARTUP、ACTIVE、LOW POWER、SHUTDOWN。通过VIO电平状态切换和往PWR_MODE寄存器写值来跳转这些状态。操作IC的时候发现不激活IC的状态只能读寄存器，写寄存器时无效。

 

五、更改USID

单独更改USID寄存器的值是改不了USID的，发现读回来的数据还是原来的。改USID要同时更改PRODUCT_ID、MANUFACTURER_ID和USID，这样才能改动USID的值，然后从机地址就跟着一起变了，下次给SA0~SA3的时候记得要替换回新的从机地址。具体时序如下：

看着那么长一段，其实就是三个寄存器写命令拼在一起。

 

六、程序代码

代码是基于STM32F103XX调试的，如下：

MIPI.h

  1. #ifndef _MIPI_H_
  2. #define _MIPI_H_
  3.  
  4. #include "stm32f10x.h"
  5. #include "public.h"
  6. #include "systick.h"
  7.  
  8. #define REG_PAC_SPST_STATE  0x00
  9. #define REG_VBODY_TIMERS    0x01
  10. #define REG_VVAR            0x02
  11. #define REG_CUSTOMER_SRATCH 0x17
  12. #define REG_RFFE_STATUS     0x1A
  13. #define REG_GROUP_SID       0x1B
  14. #define REG_PM_TRIG         0x1C
  15. #define REG_PRODUCT_ID      0x1D
  16. #define REG_MANUFACTURER_ID 0x1E
  17. #define REG_MAN_USID        0x1F
  18. #define REG_CMOS_VERSION_ID 0x21
  19. #define REG_SDATA_DRV_LVL   0x2B
  20.  
  21. #define CHECK_OK 	1
  22. #define CHECK_FAIL 	0
  23.  
  24. #define RFFE_SDATA_PORT	GPIOA
  25. #define RFFE_SDATA_PIN	GPIO_Pin_0
  26.  
  27. #define RFFE_SCLK_PORT	GPIOA
  28. #define RFFE_SCLK_PIN	GPIO_Pin_1
  29.  
  30. #define RFFE_SDATA_HIGH GPIO_SetBits(RFFE_SDATA_PORT, RFFE_SDATA_PIN)
  31. #define RFFE_SDATA_LOW	GPIO_ResetBits(RFFE_SDATA_PORT, RFFE_SDATA_PIN)
  32.  
  33. #define RFFE_SDATA_READ	GPIO_ReadInputDataBit(RFFE_SDATA_PORT, RFFE_SDATA_PIN)
  34.  
  35. #define RFFE_SCLK_HIGH GPIO_SetBits(RFFE_SCLK_PORT, RFFE_SCLK_PIN)
  36. #define RFFE_SCLK_LOW	GPIO_ResetBits(RFFE_SCLK_PORT, RFFE_SCLK_PIN)
  37.  
  38. #define Delay_nop(x) delay_us(x);
  39.  
  40. //#define Delay_nop(x) {;;;;;};
  41.  
  42. #define Bus_Park()	RFFE_SDATA_LOW
  43.  
  44. //GPIO初始化
  45. extern void RFFE_Init(void);
  46. //寄存器读
  47. extern unsigned char Register_Read(unsigned char USID_Address, unsigned char Reg_address, unsigned char *Reg_Value);
  48. //0寄存器写
  49. extern void Register_0_Write(unsigned char USID_Address, unsigned char Reg_data);
  50. //非0寄存器写，实验中发现写0寄存器也生效
  51. extern void Register_Write(unsigned char USID_Address, unsigned char Reg_Address, unsigned char Reg_data);
  52. //器件使能
  53. extern void Active_Product(unsigned char USID_Address);
  54. //必须连续一起修改Product_ID、MANUFACTURER_ID、USID才能使新的USID生效，单独修改USID寄存器不生效
  55. extern void Register_Write_USID(unsigned char Old_USID_Address, unsigned char Product_ID, unsigned short MANUFACTURER_ID, unsigned char MAN_USID);
  56. //写一个字节到扩展寄存器，扩展寄存器指地址大于0x1F的寄存器
  57. extern void Extended_Register_Write(unsigned char USID_Address, unsigned char Reg_Address, unsigned char Reg_data);
  58. //扩展寄存器读一个字节
  59. extern unsigned char Extended_Register_Read(unsigned char USID_Address, unsigned char Reg_address, unsigned char *Reg_Value);
  60.  
  61. #endif

MIPI.c

  1. #include "MIPI.h"
  2.  
  3. void RFFE_SDATA_Output_Mode(void)
  4. {
  5. 	GPIO_InitTypeDef GPIO_InitStructure;	
  6.  
  7. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); 
  8. 		
  9. 	GPIO_InitStructure.GPIO_Pin = RFFE_SDATA_PIN;	 
  10. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 
  11. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	  
  12. 	GPIO_Init(RFFE_SDATA_PORT, &GPIO_InitStructure); 
  13.  
  14. 	RFFE_SDATA_LOW;
  15. }
  16.  
  17. void RFFE_SDATA_Input_Mode(void)
  18. {
  19. 	GPIO_InitTypeDef GPIO_InitStructure;	
  20.  
  21. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); 
  22. 		
  23. 	GPIO_InitStructure.GPIO_Pin = RFFE_SDATA_PIN;	 
  24. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;	 
  25. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	  
  26. 	GPIO_Init(RFFE_SDATA_PORT, &GPIO_InitStructure); 
  27.  
  28. 	//RFFE_SDATA_LOW;
  29. }
  30.  
  31. void RFFE_SCLK_Output_Mode(void)
  32. {
  33. 	GPIO_InitTypeDef GPIO_InitStructure;	
  34.  
  35. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); 
  36. 		
  37. 	GPIO_InitStructure.GPIO_Pin = RFFE_SCLK_PIN;	 
  38. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 
  39. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	  
  40. 	GPIO_Init(RFFE_SCLK_PORT, &GPIO_InitStructure); 
  41.  
  42. 	RFFE_SCLK_LOW;
  43. }
  44.  
  45. void RFFE_Init(void)
  46. {
  47. 	RFFE_SCLK_Output_Mode();
  48. 	RFFE_SDATA_Output_Mode();
  49. 	
  50. }
  51.  
  52. void SSC_Head(void)
  53. {
  54. 	RFFE_SCLK_LOW;
  55. 	RFFE_SDATA_LOW;
  56. 	Delay_nop(10);
  57.  
  58. 	RFFE_SDATA_HIGH;
  59. 	Delay_nop(1);
  60. 	Delay_nop(1);
  61. 	Delay_nop(1);
  62.  
  63. 	RFFE_SDATA_LOW;
  64. 	Delay_nop(1);
  65. }
  66.  
  67. // void Bus_Park()
  68. // {
  69. // 	RFFE_SDATA_LOW;
  70. // 	// Delay_nop(1);
  71. // 	// RFFE_SCLK_HIGH;
  72. // }
  73.  
  74. void Register_0_Write(unsigned char USID_Address, unsigned char Reg_data)
  75. {
  76. 	int i;
  77. 	unsigned char P_Bit = 1;
  78. 	unsigned char Reg_frame_13bit[13];
  79.  
  80. 	//前四位为USID地址
  81. 	for(i = 0; i < 4; i++)
  82. 	{
  83. 		if(USID_Address & 0x80)
  84. 		{
  85. 			Reg_frame_13bit[i] = 1;
  86. 		}
  87. 		else
  88. 		{
  89. 			Reg_frame_13bit[i] = 0;
  90. 		}
  91. 		USID_Address = USID_Address << 1;
  92. 	}
  93.  
  94. 	//八位数据位，首位1为寄存器0写入标志位
  95. 	Reg_data = Reg_data | 0x80;  //加入1000b的0寄存器写入标志位
  96. 	for(i = 0; i < 8; i++)
  97. 	{
  98. 		if(Reg_data & 0x80)
  99. 		{
  100. 			Reg_frame_13bit[i + 4] = 1;
  101. 		}
  102. 		else
  103. 		{
  104. 			Reg_frame_13bit[i + 4] = 0;
  105. 		}
  106. 		Reg_data = Reg_data << 1;
  107. 	}
  108.  
  109. 	//前12位进行奇校验
  110. 	P_Bit = 1;
  111. 	for(i = 0; i < 12; i++)
  112. 	{
  113. 		if(Reg_frame_13bit[i])
  114. 		{
  115. 			P_Bit ^= 0x01;
  116. 		}
  117. 	}
  118. 	Reg_frame_13bit[12] = P_Bit;
  119.  
  120. 	//开始发送总线时序
  121. 	RFFE_SDATA_Output_Mode();
  122. 	//SSC_Head
  123. 	SSC_Head();
  124. 	RFFE_SCLK_HIGH;
  125. 	//data frame写入
  126. 	for(i = 0; i < 13; i++)
  127. 	{
  128. 		if(Reg_frame_13bit[i])
  129. 		{
  130. 			RFFE_SDATA_HIGH;
  131. 		}
  132. 		else
  133. 		{
  134. 			RFFE_SDATA_LOW;
  135. 		}
  136.  
  137. 		Delay_nop(1);
  138. 		RFFE_SCLK_HIGH;
  139. 		Delay_nop(1);
  140. 		RFFE_SCLK_LOW;
  141. 		//Delay_nop(1);
  142. 		//RFFE_SCLK_HIGH;
  143. 	}
  144.  
  145. 	//bus park
  146. 	Bus_Park();
  147. 	Delay_nop(1);
  148. 	RFFE_SCLK_HIGH;
  149. 	Delay_nop(1);
  150. 	RFFE_SCLK_LOW;
  151. }
  152.  
  153. void Register_Write(unsigned char USID_Address, unsigned char Reg_Address, unsigned char Reg_data)
  154. {
  155. 	int i;
  156. 	unsigned char P_Bit = 1;
  157. 	unsigned char Reg_frame_13bit[13];
  158. 	unsigned char Reg_data_frame_9Bit[9];
  159.  
  160. 	//前四位为USID地址
  161. 	for(i = 0; i < 4; i++)
  162. 	{
  163. 		if(USID_Address & 0x80)
  164. 		{
  165. 			Reg_frame_13bit[i] = 1;
  166. 		}
  167. 		else
  168. 		{
  169. 			Reg_frame_13bit[i] = 0;
  170. 		}
  171. 		USID_Address = USID_Address << 1;
  172. 	}
  173.  
  174. 	//八位数据位，首位1为寄存器0写入标志位
  175. 	Reg_Address &= ~((unsigned char)7 << 5);
  176. 	Reg_Address = Reg_Address | 0x40;  //加入010b的0寄存器写入标志位
  177. 	for(i = 0; i < 8; i++)
  178. 	{
  179. 		if(Reg_Address & 0x80)
  180. 		{
  181. 			Reg_frame_13bit[i + 4] = 1;
  182. 		}
  183. 		else
  184. 		{
  185. 			Reg_frame_13bit[i + 4] = 0;
  186. 		}
  187. 		Reg_Address = Reg_Address << 1;
  188. 	}
  189.  
  190. 	//前12位进行奇校验
  191. 	P_Bit = 1;
  192. 	for(i = 0; i < 12; i++)
  193. 	{
  194. 		if(Reg_frame_13bit[i])
  195. 		{
  196. 			P_Bit ^= 0x01;
  197. 		}
  198. 	}
  199. 	Reg_frame_13bit[12] = P_Bit;
  200. 	
  201. 	//处理写入寄存器的数据
  202. 	for(i = 0; i < 8; i++)
  203. 	{
  204. 		if(Reg_data & 0x80)
  205. 		{
  206. 			Reg_data_frame_9Bit[i] = 1;
  207. 		}
  208. 		else
  209. 		{
  210. 			Reg_data_frame_9Bit[i] = 0;
  211. 		}
  212. 		Reg_data = Reg_data << 1;
  213. 	}
  214.  
  215. 	//前8位进行奇校验
  216. 	P_Bit = 1;
  217. 	for(i = 0; i < 8; i++)
  218. 	{
  219. 		if(Reg_data_frame_9Bit[i])
  220. 		{
  221. 			P_Bit ^= 0x01;
  222. 		}
  223. 	}
  224. 	Reg_data_frame_9Bit[8] = P_Bit;
  225.  
  226. 	//开始发送总线时序
  227. 	RFFE_SDATA_Output_Mode();
  228. 	//SSC_Head
  229. 	SSC_Head();
  230.  
  231. 	//Reg frame写入
  232. 	for(i = 0; i < 13; i++)
  233. 	{
  234. 		if(Reg_frame_13bit[i])
  235. 		{
  236. 			RFFE_SDATA_HIGH;
  237. 		}
  238. 		else
  239. 		{
  240. 			RFFE_SDATA_LOW;
  241. 		}
  242.  
  243. 		Delay_nop(1);
  244. 		RFFE_SCLK_HIGH;
  245. 		Delay_nop(1);
  246. 		RFFE_SCLK_LOW;
  247. 		//Delay_nop(1);
  248. 	}
  249.  
  250. 	//data frame写入
  251. 	for(i = 0; i < 9; i++)
  252. 	{
  253. 		if(Reg_data_frame_9Bit[i])
  254. 		{
  255. 			RFFE_SDATA_HIGH;
  256. 		}
  257. 		else
  258. 		{
  259. 			RFFE_SDATA_LOW;
  260. 		}
  261.  
  262. 		Delay_nop(1);
  263. 		RFFE_SCLK_HIGH;
  264. 		Delay_nop(1);
  265. 		RFFE_SCLK_LOW;
  266. 		//Delay_nop(1);
  267. 	}
  268. 	
  269. 	//bus park
  270. 	Bus_Park();
  271. 	Delay_nop(1);
  272. 	RFFE_SCLK_HIGH;
  273. 	Delay_nop(1);
  274. 	RFFE_SCLK_LOW;
  275. }
  276.  
  277. unsigned char Register_Read(unsigned char USID_Address, unsigned char Reg_address, unsigned char *Reg_Value)
  278. {
  279. 	int i = 0;
  280. 	unsigned char P_Bit = 1;
  281. 	unsigned char Reg_frame_13bit[13];
  282. 	unsigned char Receive_Bit9_frame[9];
  283.  
  284. 	//实验发现需要先拉高SDATA和SCLK才能读正确
  285. 	RFFE_SDATA_Output_Mode();
  286. 	RFFE_SCLK_HIGH;
  287. 	RFFE_SDATA_HIGH;
  288. 	Delay_nop(10);
  289. 	
  290. 	RFFE_SCLK_LOW;
  291. 	Delay_nop(1);
  292. 	RFFE_SDATA_LOW;
  293. 	Delay_nop(10);
  294. 	
  295. 	//前四位为USID地址
  296. 	for(i = 0; i < 4; i++)
  297. 	{
  298. 		if(USID_Address & 0x80)
  299. 		{
  300. 			Reg_frame_13bit[i] = 1;
  301. 		}
  302. 		else
  303. 		{
  304. 			Reg_frame_13bit[i] = 0;
  305. 		}
  306. 		USID_Address = USID_Address << 1;
  307. 	}
  308.  
  309. 	//八位寄存器地址转换
  310. 	Reg_address = Reg_address | 0x60;  //加入0110b读取指令标志位
  311.  
  312. 	for(i = 4; i < 12; i++)
  313. 	{
  314. 		if(Reg_address & 0x80)
  315. 		{
  316. 			Reg_frame_13bit[i] = 1;
  317. 		}
  318. 		else
  319. 		{
  320. 			Reg_frame_13bit[i] = 0;
  321. 		}
  322. 		Reg_address = Reg_address << 1;
  323. 	}
  324.  
  325. 	//前12位进行奇校验P
  326. 	P_Bit = 1;
  327. 	for(i = 0; i < 12; i++)
  328. 	{
  329. 		if(Reg_frame_13bit[i])
  330. 		{
  331. 			P_Bit ^= 0x01;
  332. 		}
  333. 	}
  334.  
  335. 	Reg_frame_13bit[12] = P_Bit;
  336.  
  337. 	//开始发送总线时序
  338. 	RFFE_SDATA_Output_Mode();
  339. 	//SSC_Head
  340. 	SSC_Head();
  341.  
  342. 	//data frame写入
  343. 	for(i = 0; i < 13; i++)
  344. 	{
  345. 		if(Reg_frame_13bit[i])
  346. 		{
  347. 			RFFE_SDATA_HIGH;
  348. 		}
  349. 		else
  350. 		{
  351. 			RFFE_SDATA_LOW;
  352. 		}
  353.  
  354. 		Delay_nop(1);
  355. 		RFFE_SCLK_HIGH;
  356. 		Delay_nop(1);
  357. 		RFFE_SCLK_LOW;
  358. 		//Delay_nop(1);
  359. 	}
  360.  
  361. 	//bus park
  362. 	Bus_Park();
  363. 	Delay_nop(1);
  364. 	RFFE_SCLK_HIGH;
  365. 	Delay_nop(1);
  366. 	RFFE_SCLK_LOW;
  367. 	RFFE_SDATA_Input_Mode();
  368.  
  369. 	//read data数据读出，同时对数据进行奇校验
  370. 	P_Bit = 1;
  371.  
  372. 	for(i = 0; i < 9; i++)
  373. 	{
  374. 		Delay_nop(2);
  375. 		RFFE_SCLK_HIGH;
  376. 		Delay_nop(2);
  377. 		RFFE_SCLK_LOW;
  378.  
  379. 		if(RFFE_SDATA_READ)
  380. 		{
  381. 			Receive_Bit9_frame[i] = 1;
  382. 			P_Bit ^= 0x01;
  383. 		}
  384. 		else
  385. 		{
  386. 			Receive_Bit9_frame[i] = 0;
  387. 		}
  388. 	}
  389.  
  390. 	*Reg_Value = 0;
  391. 	for(i = 0; i < 8; i++)
  392. 	{
  393. 		*Reg_Value <<= 1;
  394. 		*Reg_Value |=  Receive_Bit9_frame[i] ? 1 : 0;
  395. 	}
  396.  
  397. 	//bus park
  398. 	RFFE_SDATA_Output_Mode();
  399. 	Bus_Park();
  400. 	Delay_nop(2);
  401. 	RFFE_SCLK_HIGH;
  402. 	Delay_nop(2);
  403. 	RFFE_SCLK_LOW;
  404. 	
  405. 	if(P_Bit)
  406. 	{
  407. 		//奇校验失败
  408. 		return CHECK_FAIL;
  409. 	}
  410. 	else
  411. 	{
  412. 		//奇校验成功
  413. 		return CHECK_OK;
  414. 	}
  415. }
  416.  
  417. //器件使能
  418. void Active_Product(unsigned char USID_Address)
  419. {
  420. 	Register_Write(USID_Address, 0x1C, 0x38);
  421. 	Register_Write(USID_Address, 0x02, 0x02);
  422. }
  423.  
  424. //必须连续一起修改Product_ID、MANUFACTURER_ID、USID才能使新的USID生效，单独修改USID寄存器不生效
  425. void Register_Write_USID(unsigned char Old_USID_Address, unsigned char Product_ID, unsigned short MANUFACTURER_ID, unsigned char MAN_USID)
  426. {
  427. 	Register_Write(Old_USID_Address, 0x1D, Product_ID);
  428. 	Register_Write(Old_USID_Address, 0x1E, MANUFACTURER_ID);
  429. 	Register_Write(Old_USID_Address, 0x1F, MAN_USID);
  430. }
  431.  
  432. //写一个字节到扩展寄存器，扩展寄存器指地址大于0x1F的寄存器
  433. void Extended_Register_Write(unsigned char USID_Address, unsigned char Reg_Address, unsigned char Reg_data)
  434. {
  435. 	int i;
  436. 	unsigned char P_Bit = 1;
  437. 	unsigned char Byte_len = 0;  //0代表写一个字节
  438. 	unsigned char Reg_frame_22bit[22];
  439. 	unsigned char Reg_data_frame_9Bit[9];
  440.  
  441. 	//前四位为USID地址
  442. 	for(i = 0; i < 4; i++)
  443. 	{
  444. 		if(USID_Address & 0x80)
  445. 		{
  446. 			Reg_frame_22bit[i] = 1;
  447. 		}
  448. 		else
  449. 		{
  450. 			Reg_frame_22bit[i] = 0;
  451. 		}
  452. 		USID_Address = USID_Address << 1;
  453. 	}
  454.  
  455. 	//默认写一个字节，可以改成写多个字节，多个字节会顺推写到后面的寄存器地址，最多连续写16个字节
  456. 	Byte_len &= 0x0F;
  457. 	Byte_len = Byte_len | 0x00;  
  458. 	for(i = 0; i < 8; i++)
  459. 	{
  460. 		if(Byte_len & 0x80)
  461. 		{
  462. 			Reg_frame_22bit[i + 4] = 1;
  463. 		}
  464. 		else
  465. 		{
  466. 			Reg_frame_22bit[i + 4] = 0;
  467. 		}
  468. 		Byte_len = Byte_len << 1;
  469. 	}
  470.  
  471. 	//前12位进行奇校验
  472. 	P_Bit = 1;
  473. 	for(i = 0; i < 12; i++)
  474. 	{
  475. 		if(Reg_frame_22bit[i])
  476. 		{
  477. 			P_Bit ^= 0x01;
  478. 		}
  479. 	}
  480. 	Reg_frame_22bit[12] = P_Bit;
  481.  
  482. 	//八位寄存器地址
  483. 	for(i = 0; i < 8; i++)
  484. 	{
  485. 		if(Reg_Address & 0x80)
  486. 		{
  487. 			Reg_frame_22bit[i + 13] = 1;
  488. 		}
  489. 		else
  490. 		{
  491. 			Reg_frame_22bit[i + 13] = 0;
  492. 		}
  493. 		Reg_Address = Reg_Address << 1;
  494. 	}
  495.  
  496. 	//第13 ~ 20位进行奇校验
  497. 	P_Bit = 1;
  498. 	for(i = 0; i < 8; i++)
  499. 	{
  500. 		if(Reg_frame_22bit[i + 13])
  501. 		{
  502. 			P_Bit ^= 0x01;
  503. 		}
  504. 	}
  505. 	Reg_frame_22bit[21] = P_Bit;
  506. 	
  507. 	//处理写入寄存器的数据
  508. 	for(i = 0; i < 8; i++)
  509. 	{
  510. 		if(Reg_data & 0x80)
  511. 		{
  512. 			Reg_data_frame_9Bit[i] = 1;
  513. 		}
  514. 		else
  515. 		{
  516. 			Reg_data_frame_9Bit[i] = 0;
  517. 		}
  518. 		Reg_data = Reg_data << 1;
  519. 	}
  520.  
  521. 	//前8位进行奇校验
  522. 	P_Bit = 1;
  523. 	for(i = 0; i < 8; i++)
  524. 	{
  525. 		if(Reg_data_frame_9Bit[i])
  526. 		{
  527. 			P_Bit ^= 0x01;
  528. 		}
  529. 	}
  530. 	Reg_data_frame_9Bit[8] = P_Bit;
  531.  
  532. 	//开始发送总线时序
  533. 	RFFE_SDATA_Output_Mode();
  534. 	//SSC_Head
  535. 	SSC_Head();
  536.  
  537. 	//Reg frame写入
  538. 	for(i = 0; i < 22; i++)
  539. 	{
  540. 		if(Reg_frame_22bit[i])
  541. 		{
  542. 			RFFE_SDATA_HIGH;
  543. 		}
  544. 		else
  545. 		{
  546. 			RFFE_SDATA_LOW;
  547. 		}
  548.  
  549. 		Delay_nop(1);
  550. 		RFFE_SCLK_HIGH;
  551. 		Delay_nop(1);
  552. 		RFFE_SCLK_LOW;
  553. 		//Delay_nop(1);
  554. 	}
  555.  
  556. 	//data frame写入
  557. 	for(i = 0; i < 9; i++)
  558. 	{
  559. 		if(Reg_data_frame_9Bit[i])
  560. 		{
  561. 			RFFE_SDATA_HIGH;
  562. 		}
  563. 		else
  564. 		{
  565. 			RFFE_SDATA_LOW;
  566. 		}
  567.  
  568. 		Delay_nop(1);
  569. 		RFFE_SCLK_HIGH;
  570. 		Delay_nop(1);
  571. 		RFFE_SCLK_LOW;
  572. 		//Delay_nop(1);
  573. 	}
  574. 	
  575. 	//bus park
  576. 	Bus_Park();
  577. 	Delay_nop(1);
  578. 	RFFE_SCLK_HIGH;
  579. 	Delay_nop(1);
  580. 	RFFE_SCLK_LOW;
  581. }
  582.  
  583. //扩展寄存器读一个字节
  584. unsigned char Extended_Register_Read(unsigned char USID_Address, unsigned char Reg_address, unsigned char *Reg_Value)
  585. {
  586. 	int i = 0;
  587. 	unsigned char P_Bit = 1;
  588. 	unsigned char Byte_Len = 0;  //读一个字节
  589. 	unsigned char Reg_frame_22bit[22];
  590. 	unsigned char Receive_Bit9_frame[9];
  591.  
  592. 	//实验发现需要先拉高SDATA和SCLK才能读正确
  593. 	RFFE_SDATA_Output_Mode();
  594. 	RFFE_SCLK_HIGH;
  595. 	RFFE_SDATA_HIGH;
  596. 	Delay_nop(10);
  597. 	
  598. 	RFFE_SCLK_LOW;
  599. 	Delay_nop(1);
  600. 	RFFE_SDATA_LOW;
  601. 	Delay_nop(10);
  602. 	
  603. 	//前四位为USID地址
  604. 	for(i = 0; i < 4; i++)
  605. 	{
  606. 		if(USID_Address & 0x80)
  607. 		{
  608. 			Reg_frame_22bit[i] = 1;
  609. 		}
  610. 		else
  611. 		{
  612. 			Reg_frame_22bit[i] = 0;
  613. 		}
  614. 		USID_Address = USID_Address << 1;
  615. 	}
  616.  
  617. 	//字节数目
  618. 	Byte_Len &= 0x0F;
  619. 	Byte_Len = Byte_Len | 0x20;  
  620.  
  621. 	for(i = 4; i < 12; i++)
  622. 	{
  623. 		if(Byte_Len & 0x80)
  624. 		{
  625. 			Reg_frame_22bit[i] = 1;
  626. 		}
  627. 		else
  628. 		{
  629. 			Reg_frame_22bit[i] = 0;
  630. 		}
  631. 		Byte_Len = Byte_Len << 1;
  632. 	}
  633.  
  634. 	//前12位进行奇校验P
  635. 	P_Bit = 1;
  636. 	for(i = 0; i < 12; i++)
  637. 	{
  638. 		if(Reg_frame_22bit[i])
  639. 		{
  640. 			P_Bit ^= 0x01;
  641. 		}
  642. 	}
  643. 	Reg_frame_22bit[12] = P_Bit;
  644.  
  645. 	//八位寄存器地址转换
  646. 	for(i = 13; i < 21; i++)
  647. 	{
  648. 		if(Reg_address & 0x80)
  649. 		{
  650. 			Reg_frame_22bit[i] = 1;
  651. 		}
  652. 		else
  653. 		{
  654. 			Reg_frame_22bit[i] = 0;
  655. 		}
  656. 		Reg_address = Reg_address << 1;
  657. 	}
  658.  
  659. 	//进行奇校验P
  660. 	P_Bit = 1;
  661. 	for(i = 13; i < 21; i++)
  662. 	{
  663. 		if(Reg_frame_22bit[i])
  664. 		{
  665. 			P_Bit ^= 0x01;
  666. 		}
  667. 	}
  668.  
  669. 	Reg_frame_22bit[21] = P_Bit;
  670.  
  671. 	//开始发送总线时序
  672. 	RFFE_SDATA_Output_Mode();
  673. 	//SSC_Head
  674. 	SSC_Head();
  675.  
  676. 	//data frame写入
  677. 	for(i = 0; i < 22; i++)
  678. 	{
  679. 		if(Reg_frame_22bit[i])
  680. 		{
  681. 			RFFE_SDATA_HIGH;
  682. 		}
  683. 		else
  684. 		{
  685. 			RFFE_SDATA_LOW;
  686. 		}
  687.  
  688. 		Delay_nop(1);
  689. 		RFFE_SCLK_HIGH;
  690. 		Delay_nop(1);
  691. 		RFFE_SCLK_LOW;
  692. 		//Delay_nop(1);
  693. 	}
  694.  
  695. 	//bus park
  696. 	Bus_Park();
  697. 	Delay_nop(1);
  698. 	RFFE_SCLK_HIGH;
  699. 	Delay_nop(1);
  700. 	RFFE_SCLK_LOW;
  701. 	RFFE_SDATA_Input_Mode();
  702.  
  703. 	//read data数据读出，同时对数据进行奇校验
  704. 	P_Bit = 1;
  705.  
  706. 	for(i = 0; i < 9; i++)
  707. 	{
  708. 		Delay_nop(2);
  709. 		RFFE_SCLK_HIGH;
  710. 		Delay_nop(2);
  711. 		RFFE_SCLK_LOW;
  712.  
  713. 		if(RFFE_SDATA_READ)
  714. 		{
  715. 			Receive_Bit9_frame[i] = 1;
  716. 			P_Bit ^= 0x01;
  717. 		}
  718. 		else
  719. 		{
  720. 			Receive_Bit9_frame[i] = 0;
  721. 		}
  722. 	}
  723.  
  724. 	*Reg_Value = 0;
  725. 	for(i = 0; i < 8; i++)
  726. 	{
  727. 		*Reg_Value <<= 1;
  728. 		*Reg_Value |=  Receive_Bit9_frame[i] ? 1 : 0;
  729. 	}
  730.  
  731. 	//bus park
  732. 	RFFE_SDATA_Output_Mode();
  733. 	Bus_Park();
  734. 	Delay_nop(2);
  735. 	RFFE_SCLK_HIGH;
  736. 	Delay_nop(2);
  737. 	RFFE_SCLK_LOW;
  738. 	
  739. 	if(P_Bit)
  740. 	{
  741. 		//奇校验失败
  742. 		return CHECK_FAIL;
  743. 	}
  744. 	else
  745. 	{
  746. 		//奇校验成功
  747. 		return CHECK_OK;
  748. 	}
  749. }

 

七、参考资料

《MIPI RFFE协议文档V1.10》链接：https://pan.baidu.com/s/1mnxA9TehKzA8tdSM7bdcOg  提取码：xdk3

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/704377
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号