#include "my.h"
#include "main.h"
#include "stm32f4xx_hal.h"
#include "struct.h"
#include "ssd1306.h"


extern UserData_TypeDef currentData;
extern uint16_t correctedKu[13];
extern float kNormToDAC;

static int pulseTime;
static bool isHiden;

char pString[16] = {0};			//Нужна для FloatToASCII



void setDAC(void);


void sh_applysetting(UserData_TypeDef * currentData){


	sh_SetOutGain(currentData->IKU);
	sh_SetFvch(currentData->IFV);
	sh_SetFnch(currentData->IFN);
	sh_SetPlavZeml(currentData->IPZ);
	setDAC();

}

void sh_SetOutGain(uint16_t IKU){
	switch (IKU){
	case Ku0_1:
		HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_RESET);

		break;
	case Ku0_2:
		HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_RESET);
		break;
	case Ku0_5:
		HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin,GPIO_PIN_SET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_RESET);
		break;
	case Ku1:
		HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin,GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_RESET);
		break;
		/*HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_RESET);//варик для проверки
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_RESET);*/
	case Ku2:
		HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_RESET);
		break;
	case Ku5:
		HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin,  GPIO_PIN_RESET);
		break;
	case Ku10:
		HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin,  GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_SET);
		/*HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin,  GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_SET);*/
		break;
	case Ku20:
		HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_SET);
		break;
	case Ku50:
		HAL_GPIO_WritePin(A0_GPIO_Port,  A0_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_SET);
		break;
	case Ku100:
		HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin,GPIO_PIN_SET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin,GPIO_PIN_SET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_SET);
/*		HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin,GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin,GPIO_PIN_RESET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_SET);	*/
		break;
	case Ku200:
		HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_SET);
		break;
	case Ku500:
		HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_SET);
		break;
	case Ku1000:
		HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A4_GPIO_Port, A4_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A5_GPIO_Port, A5_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(K10_GPIO_Port, K10_Pin, GPIO_PIN_SET);
		break;
	}

};


void sh_SetFvch(uint16_t IFV){  //DA9  IA2 IA3
	switch (IFV){
	case Hp0_2:
		HAL_GPIO_WritePin(A2_GPIO_Port, A2_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A3_GPIO_Port, A3_Pin, GPIO_PIN_RESET);
		break;
	case Hp1:
		HAL_GPIO_WritePin(A2_GPIO_Port, A2_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A3_GPIO_Port, A3_Pin, GPIO_PIN_RESET);
		break;
	case Hp2:
		HAL_GPIO_WritePin(A2_GPIO_Port, A2_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A3_GPIO_Port, A3_Pin, GPIO_PIN_SET);
		break;
	case Hp10:
		HAL_GPIO_WritePin(A2_GPIO_Port, A2_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A3_GPIO_Port, A3_Pin, GPIO_PIN_SET);
		break;


	}
};



void sh_SetFnch(uint16_t IFN){
	// IA6 IA7 IA8
	//{0.1, 0.3, 1, 3, 10, 30, 100};
	//Lp100, Lp300, Lp1000, Lp3000, Lp10000, Lp30000, Lp100000
	switch (IFN){
	case Lp100:
		HAL_GPIO_WritePin(A6_GPIO_Port, A6_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A7_GPIO_Port, A7_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A8_GPIO_Port, A8_Pin, GPIO_PIN_RESET);
		break;
	case Lp300:
		HAL_GPIO_WritePin(A6_GPIO_Port, A6_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A7_GPIO_Port, A7_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A8_GPIO_Port, A8_Pin, GPIO_PIN_RESET);
		break;
	case Lp1000:
		HAL_GPIO_WritePin(A6_GPIO_Port, A6_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A7_GPIO_Port, A7_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A8_GPIO_Port, A8_Pin, GPIO_PIN_RESET);
		break;
	case Lp3000:
		HAL_GPIO_WritePin(A6_GPIO_Port, A6_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A7_GPIO_Port, A7_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A8_GPIO_Port, A8_Pin, GPIO_PIN_RESET);
		break;
	case Lp10000:
		HAL_GPIO_WritePin(A6_GPIO_Port, A6_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A7_GPIO_Port, A7_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A8_GPIO_Port, A8_Pin, GPIO_PIN_SET);
		break;
	case Lp30000:
		HAL_GPIO_WritePin(A6_GPIO_Port, A6_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A7_GPIO_Port, A7_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A8_GPIO_Port, A8_Pin, GPIO_PIN_SET);
		break;
	case Lp100000:
		HAL_GPIO_WritePin(A6_GPIO_Port, A6_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(A7_GPIO_Port, A7_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(A8_GPIO_Port, A8_Pin, GPIO_PIN_SET);
		break;

	}
};


void sh_SetPlavZeml(uint16_t IPZ){
	if(IPZ==1){
		HAL_GPIO_WritePin(PZ_GPIO_Port, PZ_Pin, GPIO_PIN_RESET);}
	else
	if(IPZ==0){
		HAL_GPIO_WritePin(PZ_GPIO_Port, PZ_Pin, GPIO_PIN_SET);}

};


void setDAC(void){
	uint16_t DVD=0;
	setOffsetKuDisplay(); //todo:Костыль!! нужно поработать над архитектурой, а не считать как придется
	DVD = correctedKu[currentData.IKU]/kNormToDAC;  // Делим кореектированный множитель на коэфициент
	WRDAC(DVD);					//todo: делим uint на float - надеюсь заработает
}

void WRDAC(uint16_t DVD)
{
uint8_t i;
uint16_t dvd = DVD;

	dvd <<= 4;
	for(i = 0; i < 12; i++)
	{
		if(dvd & 0x8000)
		  HAL_GPIO_WritePin(STD_GPIO_Port, STD_Pin, GPIO_PIN_SET);
			else HAL_GPIO_WritePin(STD_GPIO_Port, STD_Pin, GPIO_PIN_RESET);

		HAL_GPIO_WritePin(SCK_GPIO_Port, SCK_Pin, GPIO_PIN_RESET);
		HAL_GPIO_WritePin(SCK_GPIO_Port, SCK_Pin, GPIO_PIN_SET);
		dvd <<= 1;
	}

	HAL_GPIO_WritePin(FL_GPIO_Port, FL_Pin, GPIO_PIN_RESET);
	HAL_GPIO_WritePin(FL_GPIO_Port, FL_Pin, GPIO_PIN_SET);
	HAL_GPIO_WritePin(STD_GPIO_Port, STD_Pin, GPIO_PIN_SET);
}


void DrawSome(int16_t some, uint8_t x, uint8_t y, uint8_t mode){  //отрисовываем  int или char
	if (some<10) OLED_DrawNum(some,  x,  y, mode);
//	else if(some>=10&&some<=15) OLED_DrawChar((some+55),  x,  y, mode); //отображаем как HEX todo: проверь
	else OLED_DrawChar(some,  x,  y, mode);

}

void PulseDrawSome(int16_t some, uint8_t x, uint8_t y, uint8_t mode){  //Моргаем надписью
	//static int pulseTime;
	//static bool isHiden;

if(!pulseTime) pulseTime=HAL_GetTick()+10; //ты у именя первый
	if(pulseTime<HAL_GetTick()){ // если текущее время больше чем пульс тайм или некоректно, например тики переполнились


		if(isHiden){pulseTime=HAL_GetTick()+900;}
		else
		pulseTime=HAL_GetTick()+10;// и считаем время следующего пульса
		isHiden=!isHiden; // меняем состояние

	};

	if (!isHiden) DrawSome(some, x, y, mode); // если не скрыт то рисуем

}



void PulseDrawStr(char *str, uint8_t x, uint8_t y, uint8_t mode){  //Моргаем надписью


	if(!pulseTime)pulseTime=HAL_GetTick()+10; //ты у именя первый
	if(pulseTime<HAL_GetTick()){ // если текущее время больше чем пульс тайм или некоректно, например тики переполнились


		if(isHiden){pulseTime=HAL_GetTick()+900;}
		else
		pulseTime=HAL_GetTick()+10;// и считаем время следующего пульса

		isHiden=!isHiden; // меняем состояние
	};

	if (!isHiden)
		OLED_DrawStr(str, x, y, mode); // если не скрыт то рисуем

}

int asciiToFloat4(uint16_t str[]){
/////определяем где точка
	float res=0;
	int dotFounded=0;
	int dotPos=0;
	for (int i=0; i<=5; i++){
		if (str[i]=='~'){   ///todo сделать проверку на несколько точек
			if(dotFounded==0){dotFounded=1; dotPos=i;}  //ставим флаг найденной точки присваиваем позицию
			else return 1;  //иначе возвращаем ошибку 1
		}
	}
	float symbol[6];
	 symbol[0]=str[0];
	 symbol[1]=str[1];
	 symbol[2]=str[2];
	 symbol[3]=str[3];
	 symbol[4]=str[4];
	 symbol[5]=str[5];

	if(dotFounded==0){
			res=(float)symbol[0]*100000+(float)symbol[1]*10000+(float)symbol[2]*1000+(float)symbol[3]*100+(float)symbol[4]*10+(float)symbol[5];
			memcpy(&currentData.SENS, &res, sizeof(float)); 	///делаем прямое копирование иначе возвращает непонятно что
			return 0;
		}


	switch(dotPos){
	case 0:
		res=(float)symbol[1]/(float)10
		+symbol[2]/(float)100
		+symbol[3]/(float)1000
		+symbol[4]/(float)10000
		+symbol[5]/(float)100000;
		break;
	case 1:
		res=symbol[0]
	   +(float)symbol[2]/10
	   +(float)symbol[3]/100
	   +(float)symbol[4]/1000
	   +(float)symbol[5]/10000;
		break;
	case 2:
		res=symbol[0]*10
		+(float)symbol[1]
	   +(float)symbol[3]/10
	   +(float)symbol[4]/100
	   +(float)symbol[5]/1000;
		break;
	case 3:
		res=symbol[0]*100
		+(float)symbol[1]*(float)10
		+(float)symbol[2]
		+(float)symbol[4]/10
		+(float)symbol[5]/100;
		break;
	case 4:
		res=symbol[0]*1000
		+(float)symbol[1]*100
		+(float)symbol[2]*10
		+(float)symbol[3]
		+(float)symbol[5]/10;
		break;
	case 5:
		res=symbol[0]*10000
		+(float)symbol[1]*1000
		+(float)symbol[2]*100
		+(float)symbol[3]*10
		+(float)symbol[4];
		break;
	default:

		break;
	}
	memcpy(&currentData.SENS, &res, sizeof(float));
	return 0;
}


uint16_t readkey(void)
{
uint16_t key = 0;

	if(HAL_GPIO_ReadPin(OK_BTN_GPIO_Port, OK_BTN_Pin) == GPIO_PIN_RESET)
		key |= OK_BTN_Pin;
	if(HAL_GPIO_ReadPin(UP_BTN_GPIO_Port, UP_BTN_Pin) == GPIO_PIN_RESET)
		key |= UP_BTN_Pin;
	if(HAL_GPIO_ReadPin(DN_BTN_GPIO_Port, DN_BTN_Pin) == GPIO_PIN_RESET)
		key |= DN_BTN_Pin;
//	if(HAL_GPIO_ReadPin(ON_GPIO_Port, ON_Pin) == GPIO_PIN_RESET) //todo: нормально сделать кнопку включения
//		key |= ON_Pin;

	return key;
}



__IO uint16_t repeat = 0;

uint16_t kbhit(void)
{
volatile uint16_t key;
  static uint32_t dreb = 0;   //дребезг
  static uint8_t first = 1;  	//признак первого момента нажатия кнопки
  static uint16_t rep = 50;


	do
	{
		key = readkey();

		if(!key)
		{
			if(dreb)
			  dreb--;
				else first = 1;
		}
		else
		{
			if(dreb < 3)
				dreb++;
		}
		//////
		//for(int i=30000; i>0; i--){;}   /// пока что вместо антидребезга
		//////
	}
	while((dreb > 0) && (dreb < 3));



	if(!key)									//если кнопки отпущены
	{
		first = 1;								//достоверно кнопки отпущены
		return 0;								//вернуть 0
	}
	else										//иначе
	{
		if(first)								//определить кнопку
		{										//только один раз
			first = 0;							//за нажатие
			repeat = rep = 32;
			return key;							//вернуть в главную функцию состояние клавиатуры
		}
		else
		{
			if(repeat)
				return 0;						//имитация свободной клавиатуры
			else
			{
				if(rep > 0)
				  rep >>= 1;
					else rep = 32;

				repeat = rep;
				//if(key == KEY_RESET_Pin)
					return 0;


				return key;
			}
		}
	}
}



char* FloatToASCII(float Val, int32_t RoundTo)
{
uint8_t idx = 0;
int32_t i;
float value, F, I;
uint32_t rnd = 0;

uint32_t Tmp32 = 0;
uint32_t Int32 = 0;
uint32_t Frac32 = 0;
uint32_t _I32 = 0;
uint32_t _F32 = 0;
uint32_t d = 0, dd = 0;
char tmparray[32];
volatile bool minus = false;

	memset(tmparray, 0, 32);
	memset(pString, 0, 16);

	value = Val;
	if(value < 0)
	minus = true;

	if((Val >= 10000.00000f)/* || (Val <= 0)*/)
	{
		if(Val <= 0)
		{
			pString[0] = '0';
			pString[1] = '~';
			pString[2] = '0';
			pString[3] = '\0';
		}
		else
		{
			pString[0] = '1';
			pString[1] = '0';
			pString[2] = '0';
			pString[3] = '0';
			pString[4] = '0';
			pString[5] = '\0';
		}

		return pString;
	}

	value = ABS(Val);
	rnd = ABS(RoundTo);
	if(RoundTo < 0)
	{
		F = modff(value, &I);
		while(rnd)
		{
			F *= 10.0f;
			rnd--;
			d++;
		}
		F = roundf(F);

		dd = 1;
		for(i = 0; i < d; i++)
			dd *= 10;

		if((uint32_t) F == dd)
		{
			F = 0;
			I += 1;
		}

	}
	else
	{
		I = roundf(value);
		F = 0.0f;
	}

	Int32 = (uint32_t) I;
	Frac32 = (uint32_t) F;
	_I32 = Int32;
	_F32 = Frac32;


	idx = 0;
	tmparray[idx++] = '\0';
	if((Int32 == 0) && (Frac32 == 0))
	{
		if(RoundTo < 0)
		{
			for(i = 0; i < abs(RoundTo); i++)
			  tmparray[idx++] = '0';
			tmparray[idx++] = '~';
		}
		tmparray[idx++] = '0';
	}
	else
	{
		if(RoundTo < 0)
		{
			for(i = 0; i < abs(RoundTo); i++)
			{
				Tmp32 = Frac32;
				Frac32 /= 10;
				Tmp32 = Tmp32 - Frac32 * 10;
				tmparray[idx++] = '0' + Tmp32;
			}
			tmparray[idx++] = '~';
		}

		if(Int32 != 0)
		{
			while(Int32)
			{
				Tmp32 = Int32;
				Int32 /= 10;
				Tmp32 = Tmp32 - Int32 * 10;
				tmparray[idx++] = '0' + Tmp32;
			}
		}
		else
		tmparray[idx++] = '0';

		if(minus)
		{
			if((_I32 != 0) || (_F32 != 0))
			tmparray[idx++] = '-';
		}
	}

	for(i = 0; i < idx; i++)
	pString[i] = tmparray[idx - i - 1];

	return pString;
}