// setup the _var_info[] table bool AP_Param::setup(const AP_Param::Info *info, uint8_t num_vars, uint16_t eeprom_size) { struct EEPROM_header hdr; _eeprom_size = eeprom_size; _var_info = info; _num_vars = num_vars; if (!check_var_info()) { return false; } serialDebug("setup %u vars", (unsigned)num_vars); // check the header eeprom_read_block(&hdr, 0, sizeof(hdr)); if (hdr.magic[0] != k_EEPROM_magic0 || hdr.magic[1] != k_EEPROM_magic1 || hdr.revision != k_EEPROM_revision) { // header doesn't match. We can't recover any variables. Wipe // the header and setup the sentinal directly after the header serialDebug("bad header in setup - erasing"); erase_all(); } return true; }
// Load all variables from EEPROM // bool AP_Param::load_all(void) { struct Param_header phdr; uint16_t ofs = sizeof(AP_Param::EEPROM_header); while (ofs < _eeprom_size) { hal.storage->read_block(&phdr, ofs, sizeof(phdr)); // note that this is an || not an && for robustness // against power off while adding a variable if (phdr.type == _sentinal_type || phdr.key == _sentinal_key || phdr.group_element == _sentinal_group) { // we've reached the sentinal return true; } const struct AP_Param::Info *info; void *ptr; info = find_by_header(phdr, &ptr); if (info != NULL) { hal.storage->read_block(ptr, ofs+sizeof(phdr), type_size((enum ap_var_type)phdr.type)); } ofs += type_size((enum ap_var_type)phdr.type) + sizeof(phdr); } // we didn't find the sentinal serialDebug("no sentinal in load_all"); return false; }
// Copy the variable's whole name to the supplied buffer. // // If the variable is a group member, prepend the group name. // void AP_Param::copy_name_token(const ParamToken *token, char *buffer, size_t buffer_size, bool force_scalar) { uint32_t group_element; const struct GroupInfo *ginfo; uint8_t idx; const struct AP_Param::Info *info = find_var_info_token(token, &group_element, &ginfo, &idx); if (info == NULL) { *buffer = 0; serialDebug("no info found"); return; } strncpy_P(buffer, info->name, buffer_size); if (ginfo != NULL) { uint8_t len = strnlen(buffer, buffer_size); if (len < buffer_size) { strncpy_P(&buffer[len], ginfo->name, buffer_size-len); } if ((force_scalar || idx != 0) && AP_PARAM_VECTOR3F == PGM_UINT8(&ginfo->type)) { // the caller wants a specific element in a Vector3f add_vector3f_suffix(buffer, buffer_size, idx); } } else if ((force_scalar || idx != 0) && AP_PARAM_VECTOR3F == PGM_UINT8(&info->type)) { add_vector3f_suffix(buffer, buffer_size, idx); } }
// scan the EEPROM looking for a given variable by header content // return true if found, along with the offset in the EEPROM where // the variable is stored // if not found return the offset of the sentinal, or bool AP_Param::scan(const AP_Param::Param_header *target, uint16_t *pofs) { struct Param_header phdr; uint16_t ofs = sizeof(AP_Param::EEPROM_header); while (ofs < _eeprom_size) { hal.storage->read_block(&phdr, ofs, sizeof(phdr)); if (phdr.type == target->type && phdr.key == target->key && phdr.group_element == target->group_element) { // found it *pofs = ofs; return true; } // note that this is an ||, not an &&, as this makes us more // robust to power off while adding a variable to EEPROM if (phdr.type == _sentinal_type || phdr.key == _sentinal_key || phdr.group_element == _sentinal_group) { // we've reached the sentinal *pofs = ofs; return false; } ofs += type_size((enum ap_var_type)phdr.type) + sizeof(phdr); } *pofs = ~0; serialDebug("scan past end of eeprom"); return false; }
// setup the _var_info[] table bool AP_Param::setup(void) { struct EEPROM_header hdr; serialDebug("setup %u vars", (unsigned)_num_vars); // check the header hal.storage->read_block(&hdr, 0, sizeof(hdr)); if (hdr.magic[0] != k_EEPROM_magic0 || hdr.magic[1] != k_EEPROM_magic1 || hdr.revision != k_EEPROM_revision) { // header doesn't match. We can't recover any variables. Wipe // the header and setup the sentinal directly after the header serialDebug("bad header in setup - erasing"); erase_all(); } return true; }
// erase all EEPROM variables by re-writing the header and adding // a sentinal void AP_Param::erase_all(void) { struct EEPROM_header hdr; serialDebug("erase_all"); // write the header hdr.magic[0] = k_EEPROM_magic0; hdr.magic[1] = k_EEPROM_magic1; hdr.revision = k_EEPROM_revision; hdr.spare = 0; eeprom_write_check(&hdr, 0, sizeof(hdr)); // add a sentinal directly after the header write_sentinal(sizeof(struct EEPROM_header)); }
// validate the _var_info[] table bool AP_Param::check_var_info(void) { uint16_t total_size = sizeof(struct EEPROM_header); for (uint8_t i=0; i<_num_vars; i++) { uint8_t type = PGM_UINT8(&_var_info[i].type); uint8_t key = PGM_UINT8(&_var_info[i].key); if (type == AP_PARAM_GROUP) { if (i == 0) { // first element can't be a group, for first() call return false; } const struct GroupInfo *group_info = (const struct GroupInfo *)PGM_POINTER(&_var_info[i].group_info); if (group_info == NULL || !check_group_info(group_info, &total_size, 0)) { return false; } } else { uint8_t size = type_size((enum ap_var_type)type); if (size == 0) { // not a valid type - the top level list can't contain // AP_PARAM_NONE return false; } total_size += size + sizeof(struct Param_header); } if (duplicate_key(i, key)) { return false; } } if (total_size > _eeprom_size) { serialDebug("total_size %u exceeds _eeprom_size %u", total_size, _eeprom_size); return false; } return true; }
// return the storage size for a AP_PARAM_* type uint8_t AP_Param::type_size(enum ap_var_type type) { switch (type) { case AP_PARAM_NONE: case AP_PARAM_GROUP: return 0; case AP_PARAM_INT8: return 1; case AP_PARAM_INT16: return 2; case AP_PARAM_INT32: return 4; case AP_PARAM_FLOAT: return 4; case AP_PARAM_VECTOR3F: return 3*4; case AP_PARAM_VECTOR6F: return 6*4; case AP_PARAM_MATRIX3F: return 3*3*4; } serialDebug("unknown type %u\n", type); return 0; }