checker_slave/source/elec_det/driver/JQDriver.c

#include "JQDriver.h"
#include "base/delay.h"
#include "hardware/adc_cfg.h"
#include "base/utility.h"
#include "hardware/power.h"
#include "hardware/timer_cfg.h"
#include "hardware/power.h"
#include "filter.h"



volatile static uint16_t jq_idle_current; 

#define JQ_IDLE_NOISE    100 

#if JQ_Read_AD_Sample_C > FIREBUS_ADC_BUF_LEN
#error "JQDriver.c Firbus AD Sample BUFFER SIZE LIMIT"
#else
volatile uint16_t* JQ_Read_AD_V = FireBus_ADC_Buf;
#endif
volatile static uint16_t jq_ad_last_sample;
static volatile CurrentSample_Range_eu buscurrent_range = Current_Max;

volatile uint16_t JQ_FreeBack_MaxCur;
volatile uint16_t JQ_FreeBack_MaxTime;
volatile uint16_t JQ_FreeBack_MinCur;
volatile uint16_t JQ_FreeBack_MinTime;

volatile uint16_t JQ_CommEnd_MaxCur = 0;
volatile uint8_t JQ_CommEnd_CurEn = 0;


volatile uint16_t JQ_EnFreeBack_Test = 0;

static void JQ_CommBegin()
{
	CurrentSampleR_Def;
	//WaitDelayEnd(200);//20ms
  //delay_ms(20);
  delay_wait_untill_ms(20);
}
static void JQ_CommEnd()
{
	uint16_t us_temp;
	//StartDelayTime();
  TimerCount_Off();
  delay_wait_start();
	if(JQ_CommEnd_CurEn > 0)
	{
		delay_os_ms(10);
		us_temp = ADC_Comm1p6mA_EndCur();
		if(us_temp > JQ_CommEnd_MaxCur)
		{
			JQ_CommEnd_MaxCur = us_temp;
		}
	}
	CurrentSampleR_Def;
}

/*
@brief 采样总线反馈数据
@param sample_count  采样次数
*/

static void JQ_Sample(uint16_t sample_count)
{
	uint16_t us_adv = 0;
	uint16_t ul_count = 0;
	jq_ad_last_sample =  GetADC_Fast(ADC_CURR_DE);
  for(ul_count = 0;ul_count < sample_count; ul_count++)
	{
		us_adv =  GetADC_Fast(ADC_CURR_DE);
		JQ_Read_AD_V[ul_count] = us_adv;
		jq_ad_last_sample = us_adv;
	}
}




/*
@brief 采样总线反馈数据，使用滤波算法
@param sample_count  采样次数
*/



static void JQ_Sample_Filtering(uint16_t sample_count)
{
	uint16_t us_adv = 0;
	uint16_t ul_count = 0;
  filter_def f={0};
	us_adv =  GetADC_Fast(ADC_CURR_DE);
  jq_ad_last_sample=us_adv;
  filter_init(&f,us_adv);
  for(ul_count = 0;ul_count < sample_count; ul_count++)
	{
    // 保证在adc转换的期间完成滤波算法
    adc_start(ADC_CURR_DE);
    filter_insert(&f,us_adv);
    us_adv=filter_get_mid(&f);
		JQ_Read_AD_V[ul_count] = us_adv;
		jq_ad_last_sample = us_adv;
		us_adv = adc_get_value(ADC_CURR_DE);
    
	}
}




/*
@brief 通信反码信息初始化
*/
void JQ_FreeBack_Prapare(uint8_t enable_flag)
{
	JQ_FreeBack_MaxCur = 0;
	JQ_FreeBack_MaxTime = 0;
	JQ_FreeBack_MinCur = 0xFFFF;
	JQ_FreeBack_MinTime = 0xFFFF;
	JQ_EnFreeBack_Test = enable_flag;
}

//@brief 采样空闲电流
void JQ_SampleIdleCurrent()
{
	uint16_t sample_count;
	uint32_t ul_adc_v = 0;
	JQBUS_W_1;
	delay_ms(1);
	JQ_Sample(JQ_Read_AD_Sample_C_IDLE);
	Bubble_Sort_u16((uint16_t*)JQ_Read_AD_V,JQ_Read_AD_Sample_C_IDLE);
	sample_count = 15;
	while(sample_count < 25)
	{
		ul_adc_v +=JQ_Read_AD_V[sample_count++];
	}
	jq_idle_current = ul_adc_v/10 + JQ_IDLE_NOISE;
	delay_us(200);
	JQBUS_W_0
	delay_us(2000);
}
/*
@brief 读取1bit数据
@rtv 返回读取结果
*/
uint16_t JQDriver_SAMPLE_Time;

uint8_t JQ_ReadBit(void)
{
	uint16_t sample_count = 0;
	uint32_t ul_adv_sum = 0;
	uint8_t uc_bit = 0;
	uint16_t uc_mincur_index = 0;
	JQBUS_W_1;
	delay_us(150);
	Get1usCount();
	JQ_Sample(JQ_Read_AD_Sample_C);
	JQDriver_SAMPLE_Time = Get1usCount();
	JQBUS_W_0;
	
	while(sample_count < JQ_Read_AD_Sample_C)
	{
		if(JQ_Read_AD_V[sample_count] > jq_idle_current )
		{
			uc_bit++;
			ul_adv_sum += JQ_Read_AD_V[sample_count] ;
		}else if(uc_bit < 2)//连续两个大于2启动检测
		{
			uc_bit = 0;
			ul_adv_sum = 0;
		}
		sample_count++;
	}
	if(uc_bit > 10)
	{
		
		/***************记录反码信息*************************/
		  ul_adv_sum = ul_adv_sum / uc_bit;
			if( JQ_EnFreeBack_Test > 0 )
			{
				if(JQ_FreeBack_MaxCur == 0)
				{
					JQ_FreeBack_MaxCur = JQ_FreeBack_MinCur = ul_adv_sum;
				}else if(ul_adv_sum > JQ_FreeBack_MaxCur){
					JQ_FreeBack_MaxCur = ul_adv_sum;
				}else if(ul_adv_sum < JQ_FreeBack_MinCur){
					JQ_FreeBack_MinCur = ul_adv_sum;
					
				}
				
				if(JQ_FreeBack_MaxTime == 0)
				{
					JQ_FreeBack_MaxTime = JQ_FreeBack_MinTime = uc_bit;
				}else if(uc_bit > JQ_FreeBack_MaxTime)
				{
					JQ_FreeBack_MaxTime = uc_bit;
				}else if(uc_bit < JQ_FreeBack_MinCur){
					JQ_FreeBack_MinTime = uc_bit;
				}
				
			}
		delay_us(1100);
		return 1;
	}else{
		delay_us(350);
		return 0;
	}
}
/*
@brief 发送不读反馈信号的命令
@param buf 命令字节缓存区
@param len 缓存区数据长度

*/
void JQ_SendBroadCast(uint8_t* buf,uint16_t len)
{
	uint8_t uc_data;
	uint8_t uc_bitcount;
	JQ_CommBegin();
	JQBUS_W_0;
	delay_ms(2);
	while(len > 0)
	{
		
		uc_bitcount = 0;
		uc_data = *buf;
		while(uc_bitcount < 8){
			if((uc_data & 0x80) > 0)
			{
				JQBUS_W_1;
				delay_us(JQBUS_H_PLUS);
				JQBUS_W_0;
				delay_us(JQBUS_L_PLUS);
			}else{
				JQBUS_W_1;
				delay_us(JQBUS_L_PLUS);
				JQBUS_W_0;
				delay_us(JQBUS_H_PLUS);
			}
			uc_bitcount++;
			uc_data <<= 1;
		}
		len--;
		buf++;
	}
	JQBUS_IDLE;
	JQ_CommEnd();
}
//@breif 发送读取命令
static void JQ_SendReadCmd(uint8_t* cmd_buf,uint16_t w_len)
{
	uint8_t uc_data;
	uint8_t uc_bitcount;
	JQBUS_W_0;
	delay_ms(2);
	while(w_len > 0)
	{

		uc_bitcount = 0;
		uc_data = *cmd_buf;
		while(uc_bitcount < 8){
			if((uc_data & 0x80) > 0)
			{
				JQBUS_W_1;
				delay_us(JQBUS_H_PLUS);
				JQBUS_W_0;
				delay_us(JQBUS_L_PLUS);
			}else{
				JQBUS_W_1;
				delay_us(JQBUS_L_PLUS);
				JQBUS_W_0;
				delay_us(JQBUS_H_PLUS);
			}
			uc_bitcount++;
			uc_data <<= 1;
		}
		w_len--;
		cmd_buf++;
	}
	JQBUS_RWIDLE;
}
/*
@brief 发送待反馈的命令
@param cmd_buf 命令数据缓存区
@param read_buf 数据反馈缓存区
@param w_len 发送缓冲区数据长度
@param r_len =0 读取1bit应答信号 > 0,读取数据长度
@rtv    应答ACK
*/
uint8_t JQ_SendRead(uint8_t* cmd_buf, uint8_t* read_buf,uint16_t w_len,uint16_t r_len)
{
	uint8_t uc_data;
	uint8_t ack = 0;
	uint8_t uc_bitcount;
	JQ_CommBegin();
	if(w_len > 0)
	{
		JQ_SendReadCmd(cmd_buf,w_len);
	}
	Power_SetSampleRange_Seep(JQDriver_Sample_R,ADC_SPEED_HIGH);
	JQ_SampleIdleCurrent();
	while(r_len > 0)
	{
		uc_data = 0;
		uc_bitcount = 0;
		while(uc_bitcount < 8)
		{
			uc_data <<= 1;
			uc_data |= (JQ_ReadBit() & 0x01);
			uc_bitcount++;
		}
		*read_buf = uc_data;
		r_len--;
		read_buf++;
	}
	ack = JQ_ReadBit();
	JQBUS_IDLE;
	Power_SetSampleCurrentRange(Current_Max);
	JQ_CommEnd();
	return ack;
}

/*
@breif 起爆命令
@param cmd_count 起爆命令发送次数
@param read_buf 读取ACK数据，1bit代表一个网络号
@param run_type  0 不读取应答信号 =1 读取应答信号 >1 读取应答信号，且强制反馈收到应答
*/

void JQ_BoomCmd(uint8_t cmd_count,uint8_t* read_buf,uint8_t run_type)
{
	static uint8_t JQBoomcmd[2]={0xA9,0xB5};
	static uint8_t JQBoomEnCmd[2] = {0x7A,0xB7};
	uint16_t us_pluscount = 0;
	uint8_t uc_data,uc_bitcount,send_count;
	send_count = 0;
	while(send_count < cmd_count)
	{
		JQ_SendBroadCast(JQBoomEnCmd,2);
		delay_os_ms(20);
		send_count++;
	}
	if(run_type == 0)
	{
		while(cmd_count > 0)
		{
			//JQ_SendBroadCast(JQBoomcmd,2);
			delay_os_ms(20);
			JQ_SendRead(JQBoomcmd,&uc_data,2,0);
			cmd_count--;
		}
		us_pluscount = 0;
		while(us_pluscount < 680)
		{
			JQBUS_W_1
			delay_us(1000);
			JQBUS_W_0
			delay_us(400);
			us_pluscount++;
		}
	}else{
		while(cmd_count > 0)
		{
			delay_os_ms(20);
			JQ_SendRead(JQBoomcmd,&uc_data,2,0);
			cmd_count--;
		}
		Power_SetSampleRange_Seep(JQDriver_Sample_R,ADC_SPEED_HIGH);
		JQ_SampleIdleCurrent();
		while(us_pluscount < 680)
		{
			uc_data = 0;
			uc_bitcount = 0;
			while(uc_bitcount < 8)
			{
				uc_data <<= 1;
				uc_data |= (JQ_ReadBit() & 0x01);
				if((run_type > 1) && (uc_data& 0x01) < 1)
				{
					delay_us(750);
				}
				uc_bitcount++;
				us_pluscount++;
			}
			*read_buf = uc_data;
			read_buf++;
			
		}
	}
	Power_SetSampleCurrentRange(Current_Max);
	JQBUS_IDLE;
	JQ_CommEnd();
}

/*
@breif 起爆使能
*/


void JQ_CheckerEnBoomCmd()
{
	static uint8_t JQBoomEnCmd[2] = {0x7A,0xB7};
	JQ_SendBroadCast(JQBoomEnCmd,2);
}

/*
@breif 起爆命令
@param plus_count 巡检脉冲个数
@rtv   巡检应答Ack 的脉冲个数

*/

uint16_t JQ_CheckerBoomCmd(uint16_t plus_count,uint16_t* us_shake)
{
	static uint8_t JQBoomcmd[2]={0xA9,0xB5};
	uint16_t us_pluscount = 0;
	uint16_t us_ack_plus = 0;
	uint16_t sample_count = 0;
	uint16_t us_bitcount = 0;
	uint16_t us_temp_shake;
	uint16_t us_max,us_min;
	JQ_CheckerEnBoomCmd();
	delay_ms(20);
	JQ_SendBroadCast(JQBoomcmd,2);
	Power_SetSampleRange_Seep(JQDriver_Sample_R,ADC_SPEED_HIGH);
	JQ_SampleIdleCurrent();
	*us_shake = JQ_Read_AD_V[JQ_Read_AD_Sample_C_IDLE-2] - JQ_Read_AD_V[2];
	while(us_pluscount < plus_count)
	{
		JQBUS_W_1;
		delay_us(100);
		//700us 延时
		JQ_Sample(JQ_Read_AD_Sample_C);
		GetMaxAndMinValue((uint16_t*)JQ_Read_AD_V,JQ_Read_AD_Sample_C,&us_max,&us_min);
		us_min = us_max - us_min;
		JQBUS_W_0;
		sample_count = 0;
		while(sample_count < JQ_Read_AD_Sample_C)
		{
			if(JQ_Read_AD_V[sample_count] > jq_idle_current )
			{
				us_bitcount++;
			}else if(us_bitcount < 2)
			{
				us_bitcount = 0;
			}
			sample_count++;
		}
		if(us_bitcount > 6)
		{
			if(us_ack_plus == 0)
			{
				us_ack_plus = us_pluscount;
			}
			else{
				us_ack_plus = ~0;
			}
			delay_us(50);
			us_bitcount = 3;
			
		}else{
			if(us_min > *us_shake)
			{
				*us_shake = us_min;
			}
			delay_us(100);
			us_bitcount = 3;
		}
		while(us_bitcount > 0)
		{
			JQ_Sample(JQ_Read_AD_Sample_C>>1);
			GetMaxAndMinValue((uint16_t*)JQ_Read_AD_V,JQ_Read_AD_Sample_C>>1,&us_max,&us_min);
		
			us_min = us_max - us_min;
			if(us_min > *us_shake)
			{
				*us_shake = us_min;
			}
			us_bitcount--;
		}
		us_pluscount++;
	}
	JQBUS_IDLE;
	JQ_CommEnd();
	return us_ack_plus;		
}

static uint16_t amend_endflag = 0;
//@brief 总线波形翻转
void JQ_TriggerPlus(uint8_t flag)
{
	if(flag == 1)
	{
		JQBUS_W_0;
	}else if(flag > 1){
		JQBUS_W_1;
	}
	amend_endflag = flag;
		
}
//@brief 时钟校准
void JQ_TimeAmend(uint16_t cycle,uint16_t delayMs)
{
	static uint8_t cmd_buf = 0x34;
	JQ_SendBroadCast(&cmd_buf,1);
	delay_os_ms(2);
	FireBus_ClkAmend(cycle, cycle/2, delayMs+100,JQ_TriggerPlus);
	while(amend_endflag != 3)
	{
		delay_ms(10);
	}
	JQBUS_IDLE;
	delay_os_ms(20);
}
//@breif 巡检
void JQ_Inspect(uint16_t maxcount,uint8_t* buf,uint8_t state)
{
	static uint8_t cmd_buf[]={0x97,0x00,0x00,0x00};
	cmd_buf[3] = state;
	JQ_SendRead(cmd_buf,buf,4,(maxcount+7)/8);
}
//@brief 启动UID扫描
void JQ_ScanUIDBegin()
{
	static uint8_t start_readuid_cmd = 0x54;
	JQ_SendBroadCast(&start_readuid_cmd,1);
}
//@brief 扫描模式读取UID
uint8_t JQ_ScanReadUID(uint16_t begnet,uint8_t* uidbuf)
{
	
	static uint8_t scan_uid_cmd[]={0x59,0x00,0x00};
	uint8_t time_out = 3;
	uint8_t*p_buf = uidbuf;
	uint8_t ack;
	rt_memset(p_buf,0,8);
	while(time_out > 0)
	{
		scan_uid_cmd[1] = (begnet >> 8);
		scan_uid_cmd[2] = begnet,
		ack = JQ_SendRead(scan_uid_cmd,p_buf,3,8);
		if(ack > 0)
		{
			return ack;
		}else{
			delay_os_ms(20);
			time_out--;
		}
	}
	return 0;
}
//@brief 读延时
uint8_t JQ_ReadDelay(uint16_t netid,uint16_t* delaybuf)
{
	static uint8_t cmd_buf[3]={0x63,0x00,0x00};
	cmd_buf[1] = (netid >> 8);
	cmd_buf[2] = netid;
	return JQ_SendRead(cmd_buf,(uint8_t*)delaybuf,3,2);
}
//@brief 写延时
void JQ_WriteDelay(uint16_t netid,uint16_t delay)
{
	static uint8_t cmd_buf[5]={0x68};
	cmd_buf[1] = (netid >> 8);
	cmd_buf[2] = netid;
	cmd_buf[3] = (delay >> 8);
	cmd_buf[4] = delay;
	JQ_SendBroadCast(cmd_buf,5);
}
//@brief 验证密码
void JQ_VerifyPWD(uint8_t* pwd)
{
	static uint8_t cmd_buf[5] = {0x76};
	rt_memcpy(&cmd_buf[1],pwd,4);
	JQ_SendBroadCast(cmd_buf,5);
}
//@brief 使能起爆
void JQ_BoomActive(void)
{
	static uint8_t cmd_buf[] = {0x7A,0xB7};
	JQ_SendBroadCast(cmd_buf,2);
}
//@brief 设置充电检测判线
void JQ_ChargJudge(uint8_t dac)
{
	static uint8_t cmd_buf[] = {0x82,0x00};
	cmd_buf[1] = dac;
	JQ_SendBroadCast(cmd_buf,2);
}
//@brief 充电
void JQ_Chage(uint16_t bgnet)
{
	static uint8_t cmd_buf[3] = {0x89};
	cmd_buf[1] = bgnet>>8;
	cmd_buf[2] = bgnet;
	JQ_SendBroadCast(cmd_buf,3);
}
//@brief 放电
void JQ_DisChage(void)
{
	static uint8_t cmd_buf[1] = {0x8A};
	JQ_SendBroadCast(cmd_buf,1);
}
//@brief 快速放电
void JQ_FastDisChage(uint8_t sw)
{
	static uint8_t cmd_buf[2] = {0x8B};
	cmd_buf[1] = sw;
	JQ_SendBroadCast(cmd_buf,2);
}
//@brief 检桥丝
void JQ_BridgeWire(void)
{
	static uint8_t cmd_buf[1] = {0x8E};
	JQ_SendBroadCast(cmd_buf,1);
}

//@brief 复位
void JQ_Reset(void)
{
	static uint8_t cmd_buf[2] = {0x55,0xAA};
	JQ_SendBroadCast(cmd_buf,2);
}
//@breif 读芯片ID
uint8_t JQ_ReadChipID(uint16_t netid,uint16_t* chipid)
{
	static uint8_t cmd_buf[3] = {0x23};
	cmd_buf[1] = netid>>8;
	cmd_buf[2] = netid;
	return JQ_SendRead(cmd_buf,(uint8_t*)chipid,3,2);
}
//@brief 读OTP
uint8_t JQ_ReadOTP(uint16_t netid,uint8_t otp_bgaddr,uint8_t read_count,uint8_t* readbuf)
{
	static uint8_t cmd_buf[4] = {0x2A};
	uint8_t otp_endaddr = otp_bgaddr+ read_count;
	cmd_buf[1] = netid>>8;
	cmd_buf[2] = netid;
	cmd_buf[3] = otp_bgaddr;
	while(otp_bgaddr < otp_endaddr)
	{
		cmd_buf[3] = otp_bgaddr;
		if(JQ_SendRead(cmd_buf,readbuf,4,1) == 0)
		{
			break;
		}
		delay_os_ms(20);
		readbuf++;
		otp_bgaddr++;
	}
	return read_count - (otp_endaddr - otp_bgaddr);
}
//@brief 写OTP

uint8_t JQ_WriteOTP(uint8_t otp_bgaddr,uint8_t write_count,uint8_t* writebuf)
{
	static uint8_t cmd_buf[3] = {0x1A};
	uint8_t otp_endaddr = otp_bgaddr+ write_count;

	while(otp_bgaddr < otp_endaddr)
	{
		cmd_buf[1] = otp_bgaddr;
		cmd_buf[2] = *writebuf;
		JQ_SendBroadCast(cmd_buf,3);
		delay_os_ms(20);
		writebuf++;
		otp_bgaddr++;
	}
	return write_count - (otp_endaddr - otp_bgaddr);
}

//写OTP使能
void JQ_EnWOTP(void)
{
	static uint8_t cmd_buf[2] = {0x1E,0xC9};
	JQ_SendBroadCast(cmd_buf,2);
}
//@breif 读取单发状态
uint8_t JQ_ReadState(uint16_t netid,uint8_t* state)
{
	static uint8_t cmd_buf[3] = {0x91};
	cmd_buf[1] = netid>>8;
	cmd_buf[2] = netid;
	return JQ_SendRead(cmd_buf,state,3,1);
}
//@braief 设置通信电压模式
uint8_t JQ_SetPowerMode(uint16_t h_vol,uint16_t m_vol)
{
	return 0;
}