#include "at32f403a_407.h"
#include "modbus_params.h"
#include "io.h"
#include <string.h>


mb_param_t mb_param[MB_PARAM_MAX];



//
void mb_init_params(void)
{
    mb_param[0].reg = 0x0100;
	mb_param[0].size = 1;
	mb_param[0].param = (uint8_t*)&input_state[0];  // Текущее состояние входа
	mb_param[0].set_handler = NULL;
    mb_param[0].check_handler = mb_check_dummy;
    
    mb_param[1].reg = 0x0101;
	mb_param[1].size = 1;
	mb_param[1].param = (uint8_t*)&input_state[1];  // Текущее состояние входа
	mb_param[1].set_handler = NULL;
    mb_param[1].check_handler = mb_check_dummy;
    
    mb_param[2].reg = 0x0102;
	mb_param[2].size = 1;
	mb_param[2].param = (uint8_t*)&input_state[2];  // Текущее состояние входа
	mb_param[2].set_handler = NULL;
    mb_param[2].check_handler = mb_check_dummy;
    
    mb_param[3].reg = 0x0103;
	mb_param[3].size = 1;
	mb_param[3].param = (uint8_t*)&input_state[3];  // Текущее состояние входа
	mb_param[3].set_handler = NULL;
    mb_param[3].check_handler = mb_check_dummy;
    
    mb_param[4].reg = 0x0104;
	mb_param[4].size = 1;
	mb_param[4].param = (uint8_t*)&input_state[4];  // Текущее состояние входа
	mb_param[4].set_handler = NULL;
    mb_param[4].check_handler = mb_check_dummy;
    
    mb_param[5].reg = 0x0105;
	mb_param[5].size = 1;
	mb_param[5].param = (uint8_t*)&input_state[5];  // Текущее состояние входа
	mb_param[5].set_handler = NULL;
    mb_param[5].check_handler = mb_check_dummy;
    
    mb_param[6].reg = 0x0106;
	mb_param[6].size = 1;
	mb_param[6].param = (uint8_t*)&input_state[6];  // Текущее состояние входа
	mb_param[6].set_handler = NULL;
    mb_param[6].check_handler = mb_check_dummy;
    
    mb_param[7].reg = 0x0107;
	mb_param[7].size = 1;
	mb_param[7].param = (uint8_t*)&input_state[7];  // Текущее состояние входа
	mb_param[7].set_handler = NULL;
    mb_param[7].check_handler = mb_check_dummy;
    
    mb_param[8].reg = 0x0110;
	mb_param[8].size = 2;
	mb_param[8].param = (uint8_t*)&input_cnt[0];  // Счетчик ипульсов
	mb_param[8].set_handler = NULL;
    mb_param[8].check_handler = mb_check_dummy;
    
    mb_param[9].reg = 0x0112;
	mb_param[9].size = 2;
	mb_param[9].param = (uint8_t*)&input_cnt[0];  // Счетчик ипульсов
	mb_param[9].set_handler = NULL;
    mb_param[9].check_handler = mb_check_dummy;
    
    mb_param[10].reg = 0x0114;
	mb_param[10].size = 2;
	mb_param[10].param = (uint8_t*)&input_cnt[0];  // Счетчик ипульсов
	mb_param[10].set_handler = NULL;
    mb_param[10].check_handler = mb_check_dummy;
    
    mb_param[11].reg = 0x0116;
	mb_param[11].size = 2;
	mb_param[11].param = (uint8_t*)&input_cnt[0];  // Счетчик ипульсов
	mb_param[11].set_handler = NULL;
    mb_param[11].check_handler = mb_check_dummy;
    
    mb_param[12].reg = 0x0118;
	mb_param[12].size = 2;
	mb_param[12].param = (uint8_t*)&input_cnt[0];  // Счетчик ипульсов
	mb_param[12].set_handler = NULL;
    mb_param[12].check_handler = mb_check_dummy;
    
    mb_param[13].reg = 0x011A;
	mb_param[13].size = 2;
	mb_param[13].param = (uint8_t*)&input_cnt[0];  // Счетчик ипульсов
	mb_param[13].set_handler = NULL;
    mb_param[13].check_handler = mb_check_dummy;
    
    mb_param[14].reg = 0x011C;
	mb_param[14].size = 2;
	mb_param[14].param = (uint8_t*)&input_cnt[0];  // Счетчик ипульсов
	mb_param[14].set_handler = NULL;
    mb_param[14].check_handler = mb_check_dummy;
    
    mb_param[15].reg = 0x011E;
	mb_param[15].size = 2;
	mb_param[15].param = (uint8_t*)&input_cnt[0];  // Счетчик ипульсов
	mb_param[15].set_handler = NULL;
    mb_param[15].check_handler = mb_check_dummy;
}


// Возвращает размер параметра в регистрах
bool mb_find_param(uint16_t reg, uint16_t *index, uint16_t *size)
{
	for (uint16_t i = 0; i < MB_PARAM_MAX; i++)
	{
		if (mb_param[i].reg == reg)
		{
			*index = i;
			*size = mb_param[i].size;
			return true;
		}
	}
	return false;
}


//
mb_delay_action_t mb_set_param(uint8_t *buf, uint16_t index)
{
	uint8_t *ptr = mb_param[index].param;

    // Если параметр только для чтения
    if (mb_param[index].check_handler == NULL)
        return MB_NO_ACTION;
    
	for (uint16_t i = 0; i < 2*mb_param[index].size; i++)
	{
		*ptr = buf[2*mb_param[index].size - 1 - i];
		ptr++;
	}
  
/*    
    if (mb_param[index].check_handler != NULL)
        mb_param[index].check_handler();
*/    
    
    mb_param[index].check_handler();
    
    if (mb_param[index].set_handler != NULL)
        return mb_param[index].set_handler();
    else
        return MB_NO_ACTION;
    
/*    
    if (mb_param[index].f_activity)
        return mb_param[index].set_handler();
    else
        return MB_NO_ACTION;
*/    
}


//
void mb_get_param(uint8_t *buf, uint16_t index)
{
	uint8_t *ptr = mb_param[index].param + 2*mb_param[index].size - 1;

	for (uint16_t i = 0; i < 2*mb_param[index].size; i++)
	{
		*buf = *ptr;
		buf++;
		ptr--;
	}

}




//
uint8_t mb_get_info(uint8_t *buf)
{
	char id_str[9] = {0};
    char model[6] = {0};
	uint32_t id_word;
	uint8_t ret = 0;	// длина пакета
	uint8_t len;

    len = strlen("Hello world");
    *buf++ = len;
    strcpy(buf, "Hello world");
    buf += len;
    ret = 1 + len;
      
#if 0    
	// ------------------------------------------------------------------- //
	// Model
	// ------------------------------------------------------------------- //
    sprintf(model, "%u", sys_settings.model);
    len = strlen(model); 
    *buf++ = len; // Model len
    memcpy(buf, model, len);
    buf += len;
    ret = 1 + len;

	// ------------------------------------------------------------------- //
	// FW version
	// ------------------------------------------------------------------- //
	*buf++ = 8; // FW version len
	memcpy(buf, sys_settings.fw_version, 8);
	buf += 8;
	ret += 9;

	// ------------------------------------------------------------------- //
	// Stm ID
	// ------------------------------------------------------------------- //
	*buf++ = 24; // STM ID len
	id_word = HAL_GetUIDw0();
	sprintf(id_str, "%08X", id_word);
	len = strlen(id_str);
	memcpy(buf, id_str, len);
	buf += len;
	ret += len;
	memset(id_str, 0, 9);
		
	id_word = HAL_GetUIDw1();
	sprintf(id_str, "%08X", id_word);
	len = strlen(id_str);
	memcpy(buf, id_str, len);
	buf += len;
	ret += len;
	memset(id_str, 0, 9);
	
	id_word = HAL_GetUIDw2();
	sprintf(id_str, "%08X", id_word);
	len = strlen(id_str);
	memcpy(buf, id_str, len);
	buf += len;
	ret += len;

	// ------------------------------------------------------------------- //	
	// Серийник
	// ------------------------------------------------------------------- //
	id_word = sys_settings.serial;
	sprintf(id_str, "%u", id_word);
	len = strlen(id_str);
	*buf++ = len;
	memcpy(buf, id_str, len);
	ret += len;
#endif
	return ret;
}




// -------------------------------------------------------------------------- //
//                      Проверка параметров                                   //
// -------------------------------------------------------------------------- //

//
void mb_check_dummy(void)
{
}