nbus/Src/nbus_memory.c

/*
 * nbus_memory.c
 *
 *  Created on: Nov 4, 2023
 *      Author: juraj
 */

#include "nbus_memory.h"

nBus_MemoryDriver *memoryImplementation;

nBus_memoryInterface_t memory_itnerface = {
	nbus_memory_store_param,  nbus_memory_read_param, nbus_is_param_active,
    nbus_read_header_data, nbus_memory_id,  nbus_get_capacity};
nBus_memoryHeader_t memoryHeader;

nBus_memoryInterface_t *getnbusMemoryInterface(void) {
  return &memory_itnerface;
}

uint8_t memory_buffer[32];

void nbus_memory_init(nBus_MemoryDriver *driver) {
  memoryImplementation = driver;
  for (uint32_t i = 0; i < 64; i++) {
    memoryHeader.params_map[i].param0 = PARAMETER_UNSET;
    memoryHeader.params_map[i].param1 = PARAMETER_UNSET;
    memoryHeader.params_map[i].param2 = PARAMETER_UNSET;
    memoryHeader.params_map[i].param3 = PARAMETER_UNSET;
  }
}

uint8_t ubus_memory_write4B(uint32_t data, uint16_t adr) {
	memory_buffer[0] = data>>24;
	memory_buffer[1] = (data>>16) & 0xFF;
	memory_buffer[2] = (data>>8) & 0xFF;
	memory_buffer[3] = (data) & 0xFF;
    return memoryImplementation->write_data(memory_buffer, adr, 4);
}

uint8_t ubus_memory_write2B(uint16_t data, uint16_t adr) {
	memory_buffer[0] = (data>>8) & 0xFF;
	memory_buffer[1] = (data) & 0xFF;
    return memoryImplementation->write_data(memory_buffer, adr, 2);
}

uint8_t ubus_memory_write1B(uint8_t data, uint16_t adr) {
	memory_buffer[0] = (data) & 0xFF;
	return memoryImplementation->write_data(memory_buffer, adr, 1);
}


nBus_memoryState_t nbus_memory_store_param(uint8_t sensor_index, uint8_t param_name,
                                    uint32_t param_value) {
  if (param_name >= 16) {
    return MEMORY_STORE_FAIL;
  }
  uint16_t addr = GET_PARAM_ADDRESS(sensor_index, param_name);
  if (addr > memoryImplementation->get_capacity()) {
    return MEMORY_STORE_FAIL;
  }

  /*
   * Write information about validity of parameter for sensor 'sensor_index'. 0 -
   * parameter not set, 0xAA - parameter is setted
   */
  uint8_t address_offset = getParameterHeaderOffset(sensor_index, param_name);
  switch (param_name % 4) {
  case 0:
    memoryHeader.params_map[address_offset].param0 = PARAMETER_VALID;
    break;
  case 1:
    memoryHeader.params_map[address_offset].param1 = PARAMETER_VALID;
    break;
  case 2:
    memoryHeader.params_map[address_offset].param2 = PARAMETER_VALID;
    break;
  case 3:
    memoryHeader.params_map[address_offset].param3 = PARAMETER_VALID;
    break;
  }

  ubus_memory_write1B(
      *(uint8_t *)(&memoryHeader.params_map[address_offset]), sensor_index);
  return ubus_memory_write4B(param_value, addr) == 0
             ? MEMORY_STORE_OK
             : MEMORY_STORE_FAIL;
}

uint32_t nbus_memory_read_param(uint8_t sensor_index, uint8_t param_name) {
  if (param_name >= 16) {
    return ERROR_VALUE_I32;
  }
  uint16_t addr = GET_PARAM_ADDRESS(sensor_index, param_name);
  if (addr > memoryImplementation->get_capacity()) {
    return ERROR_VALUE_I32;
  }
  return memoryImplementation->read_word(addr);
}

void nbus_read_header_data(void) {
  uint8_t data;
  for (uint32_t adr = 0; adr < 63; adr += 4) {
    data = memoryImplementation->read_byte(adr);
    memoryHeader.params_map[adr + 0] = *(nBus_MemorySensorParam_t *)(&data);
    data = memoryImplementation->read_byte(adr + 1);
    memoryHeader.params_map[adr + 1] = *(nBus_MemorySensorParam_t *)(&data);
    data = memoryImplementation->read_byte(adr + 2);
    memoryHeader.params_map[adr + 2] = *(nBus_MemorySensorParam_t *)(&data);
    data = memoryImplementation->read_byte(adr + 3);
    memoryHeader.params_map[adr + 3] = *(nBus_MemorySensorParam_t *)(&data);
  }
}

uint8_t nbus_memory_id(uint8_t *data) {
  return memoryImplementation->read_id(data);
}

uint32_t nbus_get_capacity(void) {
  return memoryImplementation->get_capacity();
}

uint8_t nbus_is_param_active(uint8_t sensor_index, uint8_t param_name) {
  uint8_t address_offset = getParameterHeaderOffset(sensor_index, param_name);
  uint8_t is_active;
  switch (param_name % 4) {
  case 0:
    is_active = memoryHeader.params_map[address_offset].param0;
    break;
  case 1:
    is_active = memoryHeader.params_map[address_offset].param1;
    break;
  case 2:
    is_active = memoryHeader.params_map[address_offset].param2;
    break;
  case 3:
    is_active = memoryHeader.params_map[address_offset].param3;
    break;
  default:
    is_active = 0;
  }

  return is_active;
}

// TODO pouzit upravenu funkciu z drivera: DS28EC20_writeMem
void memory_params_format(void) {
	uint8_t empty_data[32] = {
			0,0,0,0,0,0,0,0,
			0,0,0,0,0,0,0,0,
			0,0,0,0,0,0,0,0,
			0,0,0,0,0,0,0,0};
  for (uint32_t adr = 0; adr < 64; adr += 32) {
    memoryImplementation->write_data(empty_data, adr, 32);
  }
}

uint8_t getParameterHeaderOffset(uint8_t sensor_index, uint8_t param_name) {
  return (sensor_index - 1) * 4 + param_name / 4;
}