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_store_param,      nbus_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;
}

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;
  }
}

nBus_memoryState_t nbus_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 abou 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;
  }

  memoryImplementation->write_byte(
      *(uint8_t *)(&memoryHeader.params_map[address_offset]), sensor_index);
  return memoryImplementation->write_word(param_value, addr) == 0
             ? MEMORY_STORE_OK
             : MEMORY_STORE_FAIL;
}

uint32_t nbus_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) {
  for (uint32_t adr = 0; adr < 64; adr += 4) {
    memoryImplementation->write_word(0x0, adr);
  }
}

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