STM32调试MIPI RFFE协议

最新推荐文章于 2024-03-29 11:40:56 发布
最新推荐文章于 2024-03-29 11:40:56 发布
阅读量1.2w 收藏 133
点赞数 32
分类专栏： STM32 文章标签： MIPI MIPI RFFE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34254642/article/details/106293121
版权

目录

一、前言

二、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

#ifndef _MIPI_H_
#define _MIPI_H_

#include "stm32f10x.h"
#include "public.h"
#include "systick.h"

#define REG_PAC_SPST_STATE  0x00
#define REG_VBODY_TIMERS    0x01
#define REG_VVAR            0x02
#define REG_CUSTOMER_SRATCH 0x17
#define REG_RFFE_STATUS     0x1A
#define REG_GROUP_SID       0x1B
#define REG_PM_TRIG         0x1C
#define REG_PRODUCT_ID      0x1D
#define REG_MANUFACTURER_ID 0x1E
#define REG_MAN_USID        0x1F
#define REG_CMOS_VERSION_ID 0x21
#define REG_SDATA_DRV_LVL   0x2B

#define CHECK_OK 	1
#define CHECK_FAIL 	0

#define RFFE_SDATA_PORT	GPIOA
#define RFFE_SDATA_PIN	GPIO_Pin_0

#define RFFE_SCLK_PORT	GPIOA
#define RFFE_SCLK_PIN	GPIO_Pin_1

#define RFFE_SDATA_HIGH GPIO_SetBits(RFFE_SDATA_PORT, RFFE_SDATA_PIN)
#define RFFE_SDATA_LOW	GPIO_ResetBits(RFFE_SDATA_PORT, RFFE_SDATA_PIN)

#define RFFE_SDATA_READ	GPIO_ReadInputDataBit(RFFE_SDATA_PORT, RFFE_SDATA_PIN)

#define RFFE_SCLK_HIGH GPIO_SetBits(RFFE_SCLK_PORT, RFFE_SCLK_PIN)
#define RFFE_SCLK_LOW	GPIO_ResetBits(RFFE_SCLK_PORT, RFFE_SCLK_PIN)

#define Delay_nop(x) delay_us(x);

//#define Delay_nop(x) {;;;;;};

#define Bus_Park()	RFFE_SDATA_LOW

//GPIO初始化
extern void RFFE_Init(void);
//寄存器读
extern unsigned char Register_Read(unsigned char USID_Address, unsigned char Reg_address, unsigned char *Reg_Value);
//0寄存器写
extern void Register_0_Write(unsigned char USID_Address, unsigned char Reg_data);
//非0寄存器写，实验中发现写0寄存器也生效
extern void Register_Write(unsigned char USID_Address, unsigned char Reg_Address, unsigned char Reg_data);
//器件使能
extern void Active_Product(unsigned char USID_Address);
//必须连续一起修改Product_ID、MANUFACTURER_ID、USID才能使新的USID生效，单独修改USID寄存器不生效
extern void Register_Write_USID(unsigned char Old_USID_Address, unsigned char Product_ID, unsigned short MANUFACTURER_ID, unsigned char MAN_USID);
//写一个字节到扩展寄存器，扩展寄存器指地址大于0x1F的寄存器
extern void Extended_Register_Write(unsigned char USID_Address, unsigned char Reg_Address, unsigned char Reg_data);
//扩展寄存器读一个字节
extern unsigned char Extended_Register_Read(unsigned char USID_Address, unsigned char Reg_address, unsigned char *Reg_Value);

#endif

MIPI.c

#include "MIPI.h"

void RFFE_SDATA_Output_Mode(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;	

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); 
		
	GPIO_InitStructure.GPIO_Pin = RFFE_SDATA_PIN;	 
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	  
	GPIO_Init(RFFE_SDATA_PORT, &GPIO_InitStructure); 

	RFFE_SDATA_LOW;
}

void RFFE_SDATA_Input_Mode(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;	

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); 
		
	GPIO_InitStructure.GPIO_Pin = RFFE_SDATA_PIN;	 
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;	 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	  
	GPIO_Init(RFFE_SDATA_PORT, &GPIO_InitStructure); 

	//RFFE_SDATA_LOW;
}

void RFFE_SCLK_Output_Mode(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;	

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); 
		
	GPIO_InitStructure.GPIO_Pin = RFFE_SCLK_PIN;	 
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	  
	GPIO_Init(RFFE_SCLK_PORT, &GPIO_InitStructure); 

	RFFE_SCLK_LOW;
}

void RFFE_Init(void)
{
	RFFE_SCLK_Output_Mode();
	RFFE_SDATA_Output_Mode();
	
}

void SSC_Head(void)
{
	RFFE_SCLK_LOW;
	RFFE_SDATA_LOW;
	Delay_nop(10);

	RFFE_SDATA_HIGH;
	Delay_nop(1);
	Delay_nop(1);
	Delay_nop(1);

	RFFE_SDATA_LOW;
	Delay_nop(1);
}

// void Bus_Park()
// {
// 	RFFE_SDATA_LOW;
// 	// Delay_nop(1);
// 	// RFFE_SCLK_HIGH;
// }

void Register_0_Write(unsigned char USID_Address, unsigned char Reg_data)
{
	int i;
	unsigned char P_Bit = 1;
	unsigned char Reg_frame_13bit[13];

	//前四位为USID地址
	for(i = 0; i < 4; i++)
	{
		if(USID_Address & 0x80)
		{
			Reg_frame_13bit[i] = 1;
		}
		else
		{
			Reg_frame_13bit[i] = 0;
		}
		USID_Address = USID_Address << 1;
	}

	//八位数据位，首位1为寄存器0写入标志位
	Reg_data = Reg_data | 0x80;  //加入1000b的0寄存器写入标志位
	for(i = 0; i < 8; i++)
	{
		if(Reg_data & 0x80)
		{
			Reg_frame_13bit[i + 4] = 1;
		}
		else
		{
			Reg_frame_13bit[i + 4] = 0;
		}
		Reg_data = Reg_data << 1;
	}

	//前12位进行奇校验
	P_Bit = 1;
	for(i = 0; i < 12; i++)
	{
		if(Reg_frame_13bit[i])
		{
			P_Bit ^= 0x01;
		}
	}
	Reg_frame_13bit[12] = P_Bit;

	//开始发送总线时序
	RFFE_SDATA_Output_Mode();
	//SSC_Head
	SSC_Head();
	RFFE_SCLK_HIGH;
	//data frame写入
	for(i = 0; i < 13; i++)
	{
		if(Reg_frame_13bit[i])
		{
			RFFE_SDATA_HIGH;
		}
		else
		{
			RFFE_SDATA_LOW;
		}

		Delay_nop(1);
		RFFE_SCLK_HIGH;
		Delay_nop(1);
		RFFE_SCLK_LOW;
		//Delay_nop(1);
		//RFFE_SCLK_HIGH;
	}

	//bus park
	Bus_Park();
	Delay_nop(1);
	RFFE_SCLK_HIGH;
	Delay_nop(1);
	RFFE_SCLK_LOW;
}

void Register_Write(unsigned char USID_Address, unsigned char Reg_Address, unsigned char Reg_data)
{
	int i;
	unsigned char P_Bit = 1;
	unsigned char Reg_frame_13bit[13];
	unsigned char Reg_data_frame_9Bit[9];

	//前四位为USID地址
	for(i = 0; i < 4; i++)
	{
		if(USID_Address & 0x80)
		{
			Reg_frame_13bit[i] = 1;
		}
		else
		{
			Reg_frame_13bit[i] = 0;
		}
		USID_Address = USID_Address << 1;
	}

	//八位数据位，首位1为寄存器0写入标志位
	Reg_Address &= ~((unsigned char)7 << 5);
	Reg_Address = Reg_Address | 0x40;  //加入010b的0寄存器写入标志位
	for(i = 0; i < 8; i++)
	{
		if(Reg_Address & 0x80)
		{
			Reg_frame_13bit[i + 4] = 1;
		}
		else
		{
			Reg_frame_13bit[i + 4] = 0;
		}
		Reg_Address = Reg_Address << 1;
	}

	//前12位进行奇校验
	P_Bit = 1;
	for(i = 0; i < 12; i++)
	{
		if(Reg_frame_13bit[i])
		{
			P_Bit ^= 0x01;
		}
	}
	Reg_frame_13bit[12] = P_Bit;
	
	//处理写入寄存器的数据
	for(i = 0; i < 8; i++)
	{
		if(Reg_data & 0x80)
		{
			Reg_data_frame_9Bit[i] = 1;
		}
		else
		{
			Reg_data_frame_9Bit[i] = 0;
		}
		Reg_data = Reg_data << 1;
	}

	//前8位进行奇校验
	P_Bit = 1;
	for(i = 0; i < 8; i++)
	{
		if(Reg_data_frame_9Bit[i])
		{
			P_Bit ^= 0x01;
		}
	}
	Reg_data_frame_9Bit[8] = P_Bit;

	//开始发送总线时序
	RFFE_SDATA_Output_Mode();
	//SSC_Head
	SSC_Head();

	//Reg frame写入
	for(i = 0; i < 13; i++)
	{
		if(Reg_frame_13bit[i])
		{
			RFFE_SDATA_HIGH;
		}
		else
		{
			RFFE_SDATA_LOW;
		}

		Delay_nop(1);
		RFFE_SCLK_HIGH;
		Delay_nop(1);
		RFFE_SCLK_LOW;
		//Delay_nop(1);
	}

	//data frame写入
	for(i = 0; i < 9; i++)
	{
		if(Reg_data_frame_9Bit[i])
		{
			RFFE_SDATA_HIGH;
		}
		else
		{
			RFFE_SDATA_LOW;
		}

		Delay_nop(1);
		RFFE_SCLK_HIGH;
		Delay_nop(1);
		RFFE_SCLK_LOW;
		//Delay_nop(1);
	}
	
	//bus park
	Bus_Park();
	Delay_nop(1);
	RFFE_SCLK_HIGH;
	Delay_nop(1);
	RFFE_SCLK_LOW;
}

unsigned char Register_Read(unsigned char USID_Address, unsigned char Reg_address, unsigned char *Reg_Value)
{
	int i = 0;
	unsigned char P_Bit = 1;
	unsigned char Reg_frame_13bit[13];
	unsigned char Receive_Bit9_frame[9];

	//实验发现需要先拉高SDATA和SCLK才能读正确
	RFFE_SDATA_Output_Mode();
	RFFE_SCLK_HIGH;
	RFFE_SDATA_HIGH;
	Delay_nop(10);
	
	RFFE_SCLK_LOW;
	Delay_nop(1);
	RFFE_SDATA_LOW;
	Delay_nop(10);
	
	//前四位为USID地址
	for(i = 0; i < 4; i++)
	{
		if(USID_Address & 0x80)
		{
			Reg_frame_13bit[i] = 1;
		}
		else
		{
			Reg_frame_13bit[i] = 0;
		}
		USID_Address = USID_Address << 1;
	}

	//八位寄存器地址转换
	Reg_address = Reg_address | 0x60;  //加入0110b读取指令标志位

	for(i = 4; i < 12; i++)
	{
		if(Reg_address & 0x80)
		{
			Reg_frame_13bit[i] = 1;
		}
		else
		{
			Reg_frame_13bit[i] = 0;
		}
		Reg_address = Reg_address << 1;
	}

	//前12位进行奇校验P
	P_Bit = 1;
	for(i = 0; i < 12; i++)
	{
		if(Reg_frame_13bit[i])
		{
			P_Bit ^= 0x01;
		}
	}

	Reg_frame_13bit[12] = P_Bit;

	//开始发送总线时序
	RFFE_SDATA_Output_Mode();
	//SSC_Head
	SSC_Head();

	//data frame写入
	for(i = 0; i < 13; i++)
	{
		if(Reg_frame_13bit[i])
		{
			RFFE_SDATA_HIGH;
		}
		else
		{
			RFFE_SDATA_LOW;
		}

		Delay_nop(1);
		RFFE_SCLK_HIGH;
		Delay_nop(1);
		RFFE_SCLK_LOW;
		//Delay_nop(1);
	}

	//bus park
	Bus_Park();
	Delay_nop(1);
	RFFE_SCLK_HIGH;
	Delay_nop(1);
	RFFE_SCLK_LOW;
	RFFE_SDATA_Input_Mode();

	//read data数据读出，同时对数据进行奇校验
	P_Bit = 1;

	for(i = 0; i < 9; i++)
	{
		Delay_nop(2);
		RFFE_SCLK_HIGH;
		Delay_nop(2);
		RFFE_SCLK_LOW;

		if(RFFE_SDATA_READ)
		{
			Receive_Bit9_frame[i] = 1;
			P_Bit ^= 0x01;
		}
		else
		{
			Receive_Bit9_frame[i] = 0;
		}
	}

	*Reg_Value = 0;
	for(i = 0; i < 8; i++)
	{
		*Reg_Value <<= 1;
		*Reg_Value |=  Receive_Bit9_frame[i] ? 1 : 0;
	}

	//bus park
	RFFE_SDATA_Output_Mode();
	Bus_Park();
	Delay_nop(2);
	RFFE_SCLK_HIGH;
	Delay_nop(2);
	RFFE_SCLK_LOW;
	
	if(P_Bit)
	{
		//奇校验失败
		return CHECK_FAIL;
	}
	else
	{
		//奇校验成功
		return CHECK_OK;
	}
}

//器件使能
void Active_Product(unsigned char USID_Address)
{
	Register_Write(USID_Address, 0x1C, 0x38);
	Register_Write(USID_Address, 0x02, 0x02);
}

//必须连续一起修改Product_ID、MANUFACTURER_ID、USID才能使新的USID生效，单独修改USID寄存器不生效
void Register_Write_USID(unsigned char Old_USID_Address, unsigned char Product_ID, unsigned short MANUFACTURER_ID, unsigned char MAN_USID)
{
	Register_Write(Old_USID_Address, 0x1D, Product_ID);
	Register_Write(Old_USID_Address, 0x1E, MANUFACTURER_ID);
	Register_Write(Old_USID_Address, 0x1F, MAN_USID);
}

//写一个字节到扩展寄存器，扩展寄存器指地址大于0x1F的寄存器
void Extended_Register_Write(unsigned char USID_Address, unsigned char Reg_Address, unsigned char Reg_data)
{
	int i;
	unsigned char P_Bit = 1;
	unsigned char Byte_len = 0;  //0代表写一个字节
	unsigned char Reg_frame_22bit[22];
	unsigned char Reg_data_frame_9Bit[9];

	//前四位为USID地址
	for(i = 0; i < 4; i++)
	{
		if(USID_Address & 0x80)
		{
			Reg_frame_22bit[i] = 1;
		}
		else
		{
			Reg_frame_22bit[i] = 0;
		}
		USID_Address = USID_Address << 1;
	}

	//默认写一个字节，可以改成写多个字节，多个字节会顺推写到后面的寄存器地址，最多连续写16个字节
	Byte_len &= 0x0F;
	Byte_len = Byte_len | 0x00;  
	for(i = 0; i < 8; i++)
	{
		if(Byte_len & 0x80)
		{
			Reg_frame_22bit[i + 4] = 1;
		}
		else
		{
			Reg_frame_22bit[i + 4] = 0;
		}
		Byte_len = Byte_len << 1;
	}

	//前12位进行奇校验
	P_Bit = 1;
	for(i = 0; i < 12; i++)
	{
		if(Reg_frame_22bit[i])
		{
			P_Bit ^= 0x01;
		}
	}
	Reg_frame_22bit[12] = P_Bit;

	//八位寄存器地址
	for(i = 0; i < 8; i++)
	{
		if(Reg_Address & 0x80)
		{
			Reg_frame_22bit[i + 13] = 1;
		}
		else
		{
			Reg_frame_22bit[i + 13] = 0;
		}
		Reg_Address = Reg_Address << 1;
	}

	//第13 ~ 20位进行奇校验
	P_Bit = 1;
	for(i = 0; i < 8; i++)
	{
		if(Reg_frame_22bit[i + 13])
		{
			P_Bit ^= 0x01;
		}
	}
	Reg_frame_22bit[21] = P_Bit;
	
	//处理写入寄存器的数据
	for(i = 0; i < 8; i++)
	{
		if(Reg_data & 0x80)
		{
			Reg_data_frame_9Bit[i] = 1;
		}
		else
		{
			Reg_data_frame_9Bit[i] = 0;
		}
		Reg_data = Reg_data << 1;
	}

	//前8位进行奇校验
	P_Bit = 1;
	for(i = 0; i < 8; i++)
	{
		if(Reg_data_frame_9Bit[i])
		{
			P_Bit ^= 0x01;
		}
	}
	Reg_data_frame_9Bit[8] = P_Bit;

	//开始发送总线时序
	RFFE_SDATA_Output_Mode();
	//SSC_Head
	SSC_Head();

	//Reg frame写入
	for(i = 0; i < 22; i++)
	{
		if(Reg_frame_22bit[i])
		{
			RFFE_SDATA_HIGH;
		}
		else
		{
			RFFE_SDATA_LOW;
		}

		Delay_nop(1);
		RFFE_SCLK_HIGH;
		Delay_nop(1);
		RFFE_SCLK_LOW;
		//Delay_nop(1);
	}

	//data frame写入
	for(i = 0; i < 9; i++)
	{
		if(Reg_data_frame_9Bit[i])
		{
			RFFE_SDATA_HIGH;
		}
		else
		{
			RFFE_SDATA_LOW;
		}

		Delay_nop(1);
		RFFE_SCLK_HIGH;
		Delay_nop(1);
		RFFE_SCLK_LOW;
		//Delay_nop(1);
	}
	
	//bus park
	Bus_Park();
	Delay_nop(1);
	RFFE_SCLK_HIGH;
	Delay_nop(1);
	RFFE_SCLK_LOW;
}

//扩展寄存器读一个字节
unsigned char Extended_Register_Read(unsigned char USID_Address, unsigned char Reg_address, unsigned char *Reg_Value)
{
	int i = 0;
	unsigned char P_Bit = 1;
	unsigned char Byte_Len = 0;  //读一个字节
	unsigned char Reg_frame_22bit[22];
	unsigned char Receive_Bit9_frame[9];

	//实验发现需要先拉高SDATA和SCLK才能读正确
	RFFE_SDATA_Output_Mode();
	RFFE_SCLK_HIGH;
	RFFE_SDATA_HIGH;
	Delay_nop(10);
	
	RFFE_SCLK_LOW;
	Delay_nop(1);
	RFFE_SDATA_LOW;
	Delay_nop(10);
	
	//前四位为USID地址
	for(i = 0; i < 4; i++)
	{
		if(USID_Address & 0x80)
		{
			Reg_frame_22bit[i] = 1;
		}
		else
		{
			Reg_frame_22bit[i] = 0;
		}
		USID_Address = USID_Address << 1;
	}

	//字节数目
	Byte_Len &= 0x0F;
	Byte_Len = Byte_Len | 0x20;  

	for(i = 4; i < 12; i++)
	{
		if(Byte_Len & 0x80)
		{
			Reg_frame_22bit[i] = 1;
		}
		else
		{
			Reg_frame_22bit[i] = 0;
		}
		Byte_Len = Byte_Len << 1;
	}

	//前12位进行奇校验P
	P_Bit = 1;
	for(i = 0; i < 12; i++)
	{
		if(Reg_frame_22bit[i])
		{
			P_Bit ^= 0x01;
		}
	}
	Reg_frame_22bit[12] = P_Bit;

	//八位寄存器地址转换
	for(i = 13; i < 21; i++)
	{
		if(Reg_address & 0x80)
		{
			Reg_frame_22bit[i] = 1;
		}
		else
		{
			Reg_frame_22bit[i] = 0;
		}
		Reg_address = Reg_address << 1;
	}

	//进行奇校验P
	P_Bit = 1;
	for(i = 13; i < 21; i++)
	{
		if(Reg_frame_22bit[i])
		{
			P_Bit ^= 0x01;
		}
	}

	Reg_frame_22bit[21] = P_Bit;

	//开始发送总线时序
	RFFE_SDATA_Output_Mode();
	//SSC_Head
	SSC_Head();

	//data frame写入
	for(i = 0; i < 22; i++)
	{
		if(Reg_frame_22bit[i])
		{
			RFFE_SDATA_HIGH;
		}
		else
		{
			RFFE_SDATA_LOW;
		}

		Delay_nop(1);
		RFFE_SCLK_HIGH;
		Delay_nop(1);
		RFFE_SCLK_LOW;
		//Delay_nop(1);
	}

	//bus park
	Bus_Park();
	Delay_nop(1);
	RFFE_SCLK_HIGH;
	Delay_nop(1);
	RFFE_SCLK_LOW;
	RFFE_SDATA_Input_Mode();

	//read data数据读出，同时对数据进行奇校验
	P_Bit = 1;

	for(i = 0; i < 9; i++)
	{
		Delay_nop(2);
		RFFE_SCLK_HIGH;
		Delay_nop(2);
		RFFE_SCLK_LOW;

		if(RFFE_SDATA_READ)
		{
			Receive_Bit9_frame[i] = 1;
			P_Bit ^= 0x01;
		}
		else
		{
			Receive_Bit9_frame[i] = 0;
		}
	}

	*Reg_Value = 0;
	for(i = 0; i < 8; i++)
	{
		*Reg_Value <<= 1;
		*Reg_Value |=  Receive_Bit9_frame[i] ? 1 : 0;
	}

	//bus park
	RFFE_SDATA_Output_Mode();
	Bus_Park();
	Delay_nop(2);
	RFFE_SCLK_HIGH;
	Delay_nop(2);
	RFFE_SCLK_LOW;
	
	if(P_Bit)
	{
		//奇校验失败
		return CHECK_FAIL;
	}
	else
	{
		//奇校验成功
		return CHECK_OK;
	}
}

 

七、参考资料

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

 

金小庭
关注
  • 32
    点赞
  • 踩
  • 133
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
基于SSD2828和STM32的MIPI显示屏驱动系统设计与实现
qq_38334677的博客
06-11 707
在硬件层面，需要将STM32、SSD2828和MIPI显示屏连接起来。STM32与SSD2828的连接：通过SPI接口连接STM32和SSD2828，用于配置和控制SSD2828。SSD2828与MIPI显示屏的连接：通过MIPI DSI接口连接SSD2828和MIPI显示屏，用于传输显示数据。
stm32_STM32驱动mipi屏_STM32I2S_mipi_TC358870_tc358870驱动
09-11
TC358870 stm32配置代码驱动jdi7寸mipi屏幕，可以点亮，分辨率1200x1920，代码网上找的，初学代码网上拼来的，屏的资料永星驱动板读取的，带音频输出，i2s
stm32用IO模拟mipi时序
10-06
stm32 IO模拟MIPI协议 #define MIPI_DATA_IN() {GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0; GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU; GPIO_Init(GPIOE,&GPIO;_InitStructure);} #define MIPI_DATA_OUT() {GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0; GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_OD; GPIO_Init(GPIOE,&GPIO;_InitStructure);}
stm32f469 mipi 电路图
07-13
stm32f469 mipi 电路图，allegro版本PCB stm32f469 mipi 电路图，allegro版本PCB
用python语言控制STM32读写满足MIPI RFFE的代码
weixin_42588555的博客
01-17 612
STM32是一种嵌入式微控制器，它可以通过串口、SPI、I2C等接口与外部设备进行通信。而MIPI RFFE是一种用于移动设备的射频前端接口标准。 要用Python语言控制STM32读写满足MIPI RFFE的代码，需要使用Python串口库，如pyserial，来与STM32串口进行通信。同时还需要了解MIPI RFFE的通信协议，并根据协议编写相应的代码来读写数据。 示例代码： import ...
stm32_STM32驱动mipi屏_STM32I2S_mipi_TC358870_tc358870驱动.zip
10-11
stm32_STM32驱动mipi屏_STM32I2S_mipi_TC358870_tc358870驱动.zip
GPIO模拟MIPI RFFE
12-13
STM32 GPIO模拟MIPI RFFE的代码实现， MIPI 规范简介， MIPIMASTER 读写时序波形
MIPI_RFFE_协议.pdf
10-23
MIPI RFFE协议的标准 如果要使用MIPI RFFE必须严格按照此协议进行配套的软硬件设计
RFFEAnalyzer:用于MIPI RFFE协议的Saleae逻辑分析仪插件
05-18
Saleae分析仪用于MIPI RFFE接口。 OSX 在OSX中，为了编译dylib： 安装XCode 打开项目文件RFFEAnalyzer.xcodeproj 建造 在“ DerivedData”下找到输出目录，以将其包含在Saleae->选项->首选项->开发人员选项卡中 ...
MIPI_RFFE_Specification_v1-10.pdf
08-04
开发RFFE ip或者控制RFFE ip很有意义，开发wishbone_rffe ip的理论基础，共享给大家，希望对大家有帮助
linux can总线接收数据串口打包上传_预热 | 万众期待的单片机，Linux二合一的STM32MP157开发板亮相...
weixin_39778393的博客
11-10 293
100ASK_STM32MP157开发板简介100ASK_STM32MP157开发板是由百问网自主研发的STM32MP157底板+米尔核心板组成，搭载意法半导体(ST)新推出的STM32MP1多核微处理器: Cortex-A7(双核)+ Cortex-M4, 带3D GPU, 性能强劲，具有计算和图形处理能力 , 兼备高能效，实时控制和高功能集成度。STM32MP1系列微处理器产品依托意法半导体及...
STM32MP157 Linux系统移植开发篇12：Linux内核MIPI LCD驱动移植
华清远见IT实验室专栏
09-09 1267
本文章为《STM32MP157 Linux系统移植开发篇》系列中的一篇，笔者使用的开发平台为华清远见FS-MP1A开发板（STM32MP157开发板）。stm32mp157是ARM双核，2个A7核，1个M4核，A7核上可以跑Linux操作系统，M4核上可以跑FreeRTOS、RT-Thread等实时操作系统，STM32MP157开发板所以既可以学嵌入式linux，也可以学stm32单片机。针对FS-MP1A开发板，除了Linux系统移植篇外，还包括其他多系列教程，包括Cortex-A7开发篇、Cortex-
基于STM32MP157调试MIPI-DSI屏幕
qq_45147279的博客
06-10 5124
平台：STM32MP157 屏幕：mipi-dsi接口，1024x600 内核版本：linux5-4本人是第一次调试mipi屏，在157这个平台上遇到的问题有一点多，接下来简单的描述下我的调试经验 二、驱动选择 在STM32MP157的源码中，自带了一个文件名为panel-simple.c通用驱动。之前已经在这个文件调通了LCD屏幕，打开文件可以看到，其实这个文件也是可以兼容mipi-dsi的屏幕。可能有些屏幕可以使用这个文件去调试，注意是看看CONFIG_DRM_MIPI_DSI这个选项有无有选择。 而我
STM32驱动友达1.2寸圆形显示器（一）
weixin_37214729的博客
05-19 4228
友达1.2寸圆形显示器，使用SPI或MIPI驱动.........啊！有好大个坑！ 1.2寸的AMOLED，看到这个OLED，好高大上，结果是MIPI+SPI驱动，第一反应是要两种协议同时用，MIPI在STM32上好难实现，就想用SPI，看完整个手册，也没有找到初始化demo或者说也没有驱动芯片手册，这个显示驱动芯片就是我认为的巨坑：AUO W0222 ASIC，找遍某娘，问遍某服，都没听过，找了大半年，总感觉浪费了我三块屏，150大洋啊。 经过不懈努力，加上我能编会说（pian），最终在半年后的今
MIPI RFFE接口实战分享
re_call的博客
07-24 5861
简介 RFFE是RF Front-End Control Interface的简写。具体介绍可以RFFE的标准协议。本文主要介绍一些关键点，为初次设计该接口的同学一些启发或者指导。 如果做过串行接口的，对于RFFE的理解是有帮助的，因为RFFE也是一个串行接口。即使没有做过，把RFFE的关键点理解了，RFFE也是不复杂的。 两个模块有信息交换，（我们称行动的发起方为master，信息的接收方为slave），那肯定有约定，不然它们是不知道谁跟谁在交流。那对于RFFE，它采用的沟通方式从大的方面来说就两种
stm32f7网口_STM32F7 - ARM Cortex-M7 Microcontrollers - STMicroelectronics
weixin_28815535的博客
01-30 243
STM32F722REHigh-performance and DSP with FPU, Arm Cortex-M7 MCU with 512 Kbytes of Flash memory, 216 MHz CPU, Art Accelerator, L1 cache, SDRAMSTM32F722ICHigh-performance and DSP with FPU, Arm Cortex-M...
MIPI RFFE接口
最新发布
weixin_50518899的博客
03-29 1494
MIPI RFFE是一种专门针对当前及未来无线系统在(RF)前端控制界面规范。随着手机射频系统日趋复杂，业界需要一个单一控制界面解决方案。MIPI联盟的RF前端控制界面(RFFE)规范通过提供一个可连接到收发器或无线电的总线界面解决了这一难题，可用于给多种射频前端设备，如低噪声放大器(LNA)、功率放大器(PA)、天线开关、天线调谐器、DC/DC转换器、滤波器、感测器等。对5G而言，几乎没有什么比RF前端(RFFE)控制基础架构更为重要。
mipi rffe协议
11-08
MIPI RFFE（Mobile Industry Processor Interface RF Front-End）协议是一种用于移动设备射频前端的串行通信接口标准。它定义了在移动设备中连接射频模块和控制器之间的通信方式和协议。 MIPI RFFE协议可以使用几对串行线路进行全双工通信，用于在移动设备中控制和监测射频前端模块的各个参数。这些参数包括功放的增益、射频开关的状态、滤波器的频率和带宽等等。 MIPI RFFE协议在通信层面上采用了类似于传统I2C总线的两线串行通信方式，但它经过了一些优化，以适应高速和低功耗的需求。协议的数据传输速率可以从1.5 Mbps提高到1 Gbps，以满足不同应用场景的需求。 MIPI RFFE协议广泛应用于移动设备中的射频前端控制，例如智能手机、平板电脑和物联网设备等等。它简化了射频前端模块的控制和配置过程，提高了设备的性能和稳定性。 总之，MIPI RFFE协议是一种用于移动设备射频前端控制的串行通信标准，它定义了控制和监测射频前端模块的参数的通信方式和协议。它在移动设备中被广泛应用，提高了设备的性能和稳定性。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值