#include "user_driver.h"
#include "Drv_adc.h"

#include "system.h"
#include "yc11xx_bt_interface.h"
#include "att.h"
#include "core_cm0.h"
#include "yc11xx_pwm.h"
#include "user_driver.h"
#include "Drv_adc.h"
#include "yc11xx_gpio.h"
#include "yc11xx_qspi.h"
#include "LH_TaskManager.h"

/*
@file：user_driver.c
@author: LiuHao 
Creation Date：2021/07/27
Function: Add related drivers
*/

void PWM_Config(GPIO_NUM gpio, PWM_ChxTypeDef pwm_channel, uint16_t pcnt,uint16_t ncnt, PWM_ClkdivDef clk_div,START_TypeDef LEVEL, PWM_SwitchDef SWITCH);
void PWM_Config(GPIO_NUM gpio, PWM_ChxTypeDef pwm_channel, uint16_t pcnt,uint16_t ncnt, PWM_ClkdivDef clk_div,START_TypeDef LEVEL, PWM_SwitchDef SWITCH)
{
	PWM_InitTypeDef PWM_InitStruct;
	PWM_InitStruct.pwm_gpio = gpio;
	PWM_InitStruct.PWM_Channel = pwm_channel;
	PWM_InitStruct.HighLevelPeriod = pcnt;
	PWM_InitStruct.LowLevelPeriod = ncnt;
	PWM_InitStruct.pwm_ctrl.clk_div = clk_div;
	PWM_InitStruct.pwm_ctrl.StartLevel = LEVEL;
	PWM_InitStruct.pwm_ctrl.pwm_switch = SWITCH;
	PWM_Init(&PWM_InitStruct);
}
uint8_t Hal_Timer_CheckTimerClock(uint32_t frequency)
{
    uint8_t div;
    if(frequency >= HAL_MIN_48M_MIN_FREQUENCY   && frequency <= HAL_MAX_48M_MAX_FREQUENCY)
    {
        div = FREQUENCY_DIVISION_0;
    }
    else if(frequency >= HAL_MIN_24M_MIN_FREQUENCY   && frequency <= HAL_MAX_24M_MAX_FREQUENCY)
    {
        div = FREQUENCY_DIVISION_1;
    }
    else if(frequency >= HAL_MIN_12M_MIN_FREQUENCY   && frequency <= HAL_MAX_12M_MAX_FREQUENCY)
    {
        div = FREQUENCY_DIVISION_2;
    }
    else if(frequency >= HAL_MIN_6M_MIN_FREQUENCY    && frequency <= HAL_MAX_6M_MAX_FREQUENCY)
    {
        div = FREQUENCY_DIVISION_3;
    }
    else if(frequency >= HAL_MIN_3M_MIN_FREQUENCY    && frequency <= HAL_MAX_3M_MAX_FREQUENCY)
    {
        div = FREQUENCY_DIVISION_4;
    }
    else if(frequency >= HAL_MIN_1500K_MIN_FREQUENCY && frequency <= HAL_MAX_1500K_MAX_FREQUENCY)
    {
        div = FREQUENCY_DIVISION_5;
    }
    else if(frequency >= HAL_MIN_750K_MIN_FREQUENCY  && frequency <= HAL_MAX_750K_MAX_FREQUENCY)
    {
        div = FREQUENCY_DIVISION_6;
    }
    else if(frequency >= HAL_MIN_375K_MIN_FREQUENCY  && frequency <= HAL_MAX_375K_MAX_FREQUENCY)
    {
        div = FREQUENCY_DIVISION_7;
    }

    return div;
}
/**
#define FREQUENCY_48M_1US 48
#define FREQUENCY_24M_1US 24
#define FREQUENCY_12M_1US 12
#define FREQUENCY_6M_1US 6
#define FREQUENCY_3M_1US 3
#define FREQUENCY_1500K_3US 2
#define FREQUENCY_750K_3US 4
#define FREQUENCY_375K_3US 8
*/
uint16_t Hal_Timer_GetOneCycleCount(uint32_t frequency,uint8_t clock)
{
    uint32_t count;
    switch (clock)
    {
    case FREQUENCY_DIVISION_0: //48M
        count = 48000000 / frequency;
        break;
    case FREQUENCY_DIVISION_1:
        count = 24000000 / frequency;
        break;
    case FREQUENCY_DIVISION_2:
        count = 12000000 / frequency;
        break;
    case FREQUENCY_DIVISION_3:
        count = 6000000 / frequency;
        break;
    case FREQUENCY_DIVISION_4:
        count = 3000000 / frequency;
        break;
    case FREQUENCY_DIVISION_5:
        // count = 2000000 / (3*frequency);
        count = 1500000 / (frequency);
        break;
    case FREQUENCY_DIVISION_6:
        count = 750000 / (frequency);
        break;
    case FREQUENCY_DIVISION_7:
        count = 375000 / (frequency);
        break;
    default:
			  break;
    }
    
    return count;
}
void UserSet_OutPWM(GPIO_NUM gpio, PWM_ChxTypeDef pwm_channel,uint32_t frequecy,uint32_t percent){
	 
	if(percent>=100)
	{
	   GPIO_SetOut(gpio,OUT_HIGH);
	}
	else if(percent==0)
	{
	  GPIO_SetOut(gpio,OUT_LOW);
	}
	else
	{
   uint8_t divClk=0;
	 uint32_t count=0;uint32_t pCnt=0,nCnt,temp=0;
	 divClk = Hal_Timer_CheckTimerClock(frequecy*2); //分频数 
   temp = Hal_Timer_GetOneCycleCount(frequecy*2, divClk); //单个周期计数值 
#ifdef DEBUG_PWM
	MyPrintf("DivClk=%x,temp=%x\r\n",divClk,temp);
#endif
   
	 pCnt = (uint32_t)((float)(temp * percent * 100)/10000.0); 
		if(!(temp > pCnt))//error
		{
			#ifdef DEBUG_PWM
			 MyPrintf("\r\nerror\r\n",pCnt,nCnt);
			#endif
			 return;
		}
	nCnt = temp - pCnt;
		#ifdef DEBUG_PWM
	MyPrintf("\r\ntemp=%d,pCnt=%d,nCnt=%d\r\n",temp,pCnt,nCnt);
		#endif
	PWM_Config(gpio,pwm_channel,pCnt,nCnt,divClk,OutputLow,PWM_ENABLE);//no分频 
	}
}

/*以下处理ADC相关代码*/
void ADC_Configuration(void);
/**
  * @brief  ADC initialization function.
  * @param  None
  * @retval None
  */
void ADC_Configuration(void)
{
	GPIO_SetGpioMultFunction(ADC_GET_GPIOx,GPCFG_NO_IE);
	
	ADC_InitTypeDef ADCInitStruct;
	ADCInitStruct.ADC_Channel = ADC_CHANNEL_5;
	ADCInitStruct.ADC_Mode = ADC_GPIO;
#ifdef hvin_test
	ADCInitStruct.ADC_Mode = ADC_HVIN;
#endif
	ADC_Init(&ADCInitStruct);
#ifdef DEBUG_ADC
//	printf("adc_init suc, gpio mode test 0-1.2V!\n");
	MyPrintf("testing channel %d\n",ADCInitStruct.ADC_Channel);
#endif
}

#include "yc11xx_gpio.h"
#include "Drv_mic.h"
#include <stdlib.h>
#include <math.h>
extern MIC_CUR_VARIABLE sMicCurVariable;
/*
 * @method Audio_sampling_init
 * @brief  mic adc init
 * @retval None
 */
void Audio_sampling_init()
{
	DRV_Mic_Init();
	DRV_Mic_Enable();
}
/*
 * @method Audio_get_buffer_len
 * @brief  Get adc dma buf unread data length.
 * @retval None
 */
int Audio_get_buffer_len()
{
	int audioWPtr = HREADW(CORE_ADCD_ADDR) ;
	int audioRPtr = TO_16BIT_ADDR(sMicCurVariable.mReadPtr) ;
	int audioBufferLen = (int)(sMicCurVariable.mEndPtr - sMicCurVariable.mReadBufPtr);
	if(audioRPtr <= audioWPtr)
	{
		return (audioWPtr - audioRPtr);
	}
	else
	{
		return (audioBufferLen - (audioRPtr - audioWPtr));
	}
}
/*
 * @method Audio_to_uart_start
 * @brief  read mic adc data for adc_dma_buf, and send  mic adc data by uart.
 * @retval None
 */
//short testPtr=NULL;
//void Audio_to_uart_start()
//{
//	uint8_t audioVal=0;
//	if (sMicCurVariable.mMicEnable == MIC_DISABLE)
//		return;
//	int audioWPtr = HREADW(CORE_ADCD_ADDR) ;
//	int bufferLen = Audio_get_buffer_len();
//		
//	if (bufferLen != 0 && bufferLen >= ENCODE_INPUT_LEN)
//	{
//		//Original sound sampling(pcm)
//		for(int indexL = 0; indexL < ENCODE_INPUT_LEN; indexL++)
//		{
//			 audioVal = *(sMicCurVariable.mReadPtr + indexL);
//				printfsend(&audioVal,1);
//			//MyPrintf("n:%d  v:%d\r\n",indexL,*(sMicCurVariable.mReadPtr + indexL));
//		}
//		sMicCurVariable.mReadPtr += ENCODE_INPUT_LEN;	
//		if (sMicCurVariable.mReadPtr == sMicCurVariable.mEndPtr)
//			sMicCurVariable.mReadPtr = sMicCurVariable.mReadBufPtr;
//	}

//}


/*
 * @method Audio_to_uart_start
 * @brief  read mic adc data for adc_dma_buf, and send  mic adc data by uart.
 * @retval None
 */
short * testPtr=NULL;
short Audio_Buffer[ENCODE_INPUT_LEN]={0};

//参数为数据，采样个数
//返回值为分贝
#define VOLUMEMAX   32767
int SimpleCalculate_DB(short* pcmData, int sample)
{
    signed short ret = 0;
    if (sample > 0){
        long sum = 0;
        signed short* pos = (signed short *)pcmData;
        for (int i = 0; i < sample; i++){
            sum += abs(*pos);
            pos++;
        }
        ret = sum * 500.0 / (sample * VOLUMEMAX);
        if (ret >= 100){
            ret = 100;
        }
   }
   return ret;
}

//计算均方根（RMS） 即能量值
static const float kMaxSquaredLevel = 32768 * 32768;
const float kMinLevel = 30.f;
int Process(const int16_t* data, size_t length) 
{
    float sum_square_ = 0;
    size_t sample_count_ = 0;
    for (size_t i = 0; i < length; ++i) {
        sum_square_ += data[i] * data[i];
    }
    sample_count_ += length;
    float rms = sum_square_ / (sample_count_ * kMaxSquaredLevel);
    //20log_10(x^0.5) = 10log_10(x)
    rms = 10 * log10(rms);
    if (rms < -kMinLevel)
        rms = -kMinLevel;
    rms = -rms;
    return (rms + 0.5);
}


static unsigned long long AudioSumVal=0;//
static unsigned int AudioCntIdx=0;
static unsigned char AudioDbVal=0;//分贝值

void Audio_to_uart_start()
{
//	char audioVal=0;
	 	short audioVal=0;
	if (sMicCurVariable.mMicEnable == MIC_DISABLE)
		return;
	int audioWPtr = HREADW(CORE_ADCD_ADDR) ;
	int bufferLen = Audio_get_buffer_len();
		
	if (bufferLen != 0 && bufferLen >= ENCODE_INPUT_LEN)
	{

		//Original sound sampling(pcm)
		testPtr = (short *)sMicCurVariable.mReadPtr;
		for(int indexL = 0; indexL < (ENCODE_INPUT_LEN>>1); indexL++)
		{
			   //audioVal = *(testPtr+ indexL)/10; //串口显示波形用
			   //printfsend(&audioVal,1);
			   audioVal = *(testPtr+ indexL);
			   
			  if(AudioCntIdx<ENCODE_INPUT_LEN*100)
				{
								AudioSumVal+=abs(*(testPtr+ indexL));
								AudioCntIdx++;
				}else
		    {
				      AudioCntIdx=0;
					    AudioDbVal = (int)(10.0*log10(AudioSumVal));  
						 AudioSumVal=0;
						 MyPrintf("val:%ddb\r\n",AudioDbVal);//计算分贝值打印 
				}

				//MyPrintf("%c",*(sMicCurVariable.mReadPtr + indexL));
			  //MyPrintf("%d\r\n",*(testPtr+ indexL)/10);
		}
		
	//	MyPrintf("val:%ddb\r\n",SimpleCalculate_DB(Audio_Buffer,ENCODE_INPUT_LEN));//计算分贝值打印 
		sMicCurVariable.mReadPtr += ENCODE_INPUT_LEN;	
		if (sMicCurVariable.mReadPtr == sMicCurVariable.mEndPtr)
			sMicCurVariable.mReadPtr = sMicCurVariable.mReadBufPtr;
	}

}


void u_ble_data_send(uint8_t *send_data, uint8_t send_len) /*实现发送ble数据包功能函数*/
{
  Bt_SndBleData(BLE_SEND_HANDLE,send_data,send_len);
}

uint32_t HW_Get_Native_Clk_Avoid_Race(void) //返回系统运行时间毫秒数
{
     uint32_t native_clk=0;
     native_clk = sys_time_handle.get_run_tickms();
     return native_clk;
}
//实现对flash的操作 api
void flash_erase_sector(uint32_t address)
{
    QSPI_SectorEraseFlash(address); 
}
void flash_read_data (uint8_t *buffer, uint32_t address, uint32_t len)
{
  QSPI_ReadFlashData(address,len,buffer);
}
void flash_write_data (uint8_t *buffer, uint32_t address, uint32_t len)
{
  QSPI_WriteFlashData(address,len,buffer);
}