// Find a variable by name. // AP_Param * AP_Param::find(const char *name, enum ap_var_type *ptype) { for (uint8_t i=0; i<_num_vars; i++) { uint8_t type = PGM_UINT8(&_var_info[i].type); if (type == AP_PARAM_GROUP) { uint8_t len = strnlen_P(_var_info[i].name, AP_MAX_NAME_SIZE); if (strncmp_P(name, _var_info[i].name, len) != 0) { continue; } const struct GroupInfo *group_info = (const struct GroupInfo *)PGM_POINTER(&_var_info[i].group_info); AP_Param *ap = find_group(name + len, i, group_info, ptype); if (ap != NULL) { return ap; } // we continue looking as we want to allow top level // parameter to have the same prefix name as group // parameters, for example CAM_P_G } else if (strcasecmp_P(name, _var_info[i].name) == 0) { *ptype = (enum ap_var_type)type; return (AP_Param *)PGM_POINTER(&_var_info[i].ptr); } } return NULL; }
// find the info structure for a variable const struct AP_Param::Info *AP_Param::find_var_info_token(const ParamToken *token, uint32_t * group_element, const struct GroupInfo ** group_ret, uint8_t * idx) { uint8_t i = token->key; uint8_t type = PGM_UINT8(&_var_info[i].type); uintptr_t base = PGM_POINTER(&_var_info[i].ptr); if (type == AP_PARAM_GROUP) { const struct GroupInfo *group_info = (const struct GroupInfo *)PGM_POINTER(&_var_info[i].group_info); const struct AP_Param::Info *info; info = find_var_info_group(group_info, i, 0, 0, group_element, group_ret, idx); if (info != NULL) { return info; } } else if (base == (uintptr_t) this) { *group_element = 0; *group_ret = NULL; *idx = 0; return &_var_info[i]; } else if (type == AP_PARAM_VECTOR3F && (base+sizeof(float) == (uintptr_t) this || base+2*sizeof(float) == (uintptr_t) this)) { // we are inside a Vector3f. Work out which element we are // referring to. *idx = (((uintptr_t) this) - base)/sizeof(float); *group_element = 0; *group_ret = NULL; return &_var_info[i]; } return NULL; }
// find the info structure for a variable in a group const struct AP_Param::Info *AP_Param::find_var_info_group(const struct GroupInfo * group_info, uint8_t vindex, uint8_t group_base, uint8_t group_shift, uint32_t * group_element, const struct GroupInfo **group_ret, uint8_t * idx) { uintptr_t base = PGM_POINTER(&_var_info[vindex].ptr); uint8_t type; for (uint8_t i=0; (type=PGM_UINT8(&group_info[i].type)) != AP_PARAM_NONE; i++) { uintptr_t ofs = PGM_POINTER(&group_info[i].offset); #ifdef AP_NESTED_GROUPS_ENABLED if (type == AP_PARAM_GROUP) { const struct GroupInfo *ginfo = (const struct GroupInfo *)PGM_POINTER(&group_info[i].group_info); // a nested group if (group_shift + _group_level_shift >= _group_bits) { // too deeply nested - this should have been caught by // setup() ! return NULL; } const struct AP_Param::Info *info; info = find_var_info_group(ginfo, vindex, GROUP_ID(group_info, group_base, i, group_shift), group_shift + _group_level_shift, group_element, group_ret, idx); if (info != NULL) { return info; } } else // Forgive the poor formatting - if continues below. #endif // AP_NESTED_GROUPS_ENABLED if ((uintptr_t) this == base + ofs) { *group_element = GROUP_ID(group_info, group_base, i, group_shift); *group_ret = &group_info[i]; *idx = 0; return &_var_info[vindex]; } else if (type == AP_PARAM_VECTOR3F && (base+ofs+sizeof(float) == (uintptr_t) this || base+ofs+2*sizeof(float) == (uintptr_t) this)) { // we are inside a Vector3f. We need to work out which // element of the vector the current object refers to. *idx = (((uintptr_t) this) - (base+ofs))/sizeof(float); *group_element = GROUP_ID(group_info, group_base, i, group_shift); *group_ret = &group_info[i]; return &_var_info[vindex]; } } return NULL; }
/// Returns the next variable in a group, recursing into groups /// as needed AP_Param *AP_Param::next_group(uint8_t vindex, const struct GroupInfo *group_info, bool *found_current, uint8_t group_base, uint8_t group_shift, ParamToken *token, enum ap_var_type *ptype) { enum ap_var_type type; for (uint8_t i=0; (type=(enum ap_var_type)PGM_UINT8(&group_info[i].type)) != AP_PARAM_NONE; i++) { #ifdef AP_NESTED_GROUPS_ENABLED if (type == AP_PARAM_GROUP) { // a nested group const struct GroupInfo *ginfo = (const struct GroupInfo *)PGM_POINTER(&group_info[i].group_info); AP_Param *ap; ap = next_group(vindex, ginfo, found_current, GROUP_ID(group_info, group_base, i, group_shift), group_shift + _group_level_shift, token, ptype); if (ap != NULL) { return ap; } } else #endif // AP_NESTED_GROUPS_ENABLED { if (*found_current) { // got a new one token->key = vindex; token->group_element = GROUP_ID(group_info, group_base, i, group_shift); token->idx = 0; if (ptype != NULL) { *ptype = type; } return (AP_Param*)(PGM_POINTER(&_var_info[vindex].ptr) + PGM_UINT16(&group_info[i].offset)); } if (GROUP_ID(group_info, group_base, i, group_shift) == token->group_element) { *found_current = true; if (type == AP_PARAM_VECTOR3F && token->idx < 3) { // return the next element of the vector as a // float token->idx++; if (ptype != NULL) { *ptype = AP_PARAM_FLOAT; } uintptr_t ofs = (uintptr_t)PGM_POINTER(&_var_info[vindex].ptr) + PGM_UINT16(&group_info[i].offset); ofs += sizeof(float)*(token->idx-1); return (AP_Param *)ofs; } } } } return NULL; }
// Load the variable from EEPROM, if supported // bool AP_Param::load(void) { uint32_t group_element = 0; const struct GroupInfo *ginfo; uint8_t idx; const struct AP_Param::Info *info = find_var_info(&group_element, &ginfo, &idx); if (info == NULL) { // we don't have any info on how to load it return false; } struct Param_header phdr; // create the header we will use to match the variable if (ginfo != NULL) { phdr.type = PGM_UINT8(&ginfo->type); } else { phdr.type = PGM_UINT8(&info->type); } phdr.key = PGM_UINT8(&info->key); phdr.group_element = group_element; // scan EEPROM to find the right location uint16_t ofs; if (!scan(&phdr, &ofs)) { // if the value isn't stored in EEPROM then set the default value if (ginfo != NULL) { uintptr_t base = PGM_POINTER(&info->ptr); set_value((enum ap_var_type)phdr.type, (void*)(base + PGM_UINT16(&ginfo->offset)), get_default_value(&ginfo->def_value)); } else { set_value((enum ap_var_type)phdr.type, (void*)PGM_POINTER(&info->ptr), get_default_value(&info->def_value)); } return false; } if (phdr.type != AP_PARAM_VECTOR3F && idx != 0) { // only vector3f can have non-zero idx for now return false; } AP_Param *ap; ap = this; if (idx != 0) { ap = (AP_Param *)((uintptr_t)ap) - (idx*sizeof(float)); } // found it _storage.read_block(ap, ofs+sizeof(phdr), type_size((enum ap_var_type)phdr.type)); return true; }
/// Returns the next variable in _var_info, recursing into groups /// as needed AP_Param *AP_Param::next(ParamToken *token, enum ap_var_type *ptype) { uint8_t i = token->key; bool found_current = false; if (i >= _num_vars) { // illegal token return NULL; } enum ap_var_type type = (enum ap_var_type)PGM_UINT8(&_var_info[i].type); // allow Vector3f to be seen as 3 variables. First as a vector, // then as 3 separate floats if (type == AP_PARAM_VECTOR3F && token->idx < 3) { token->idx++; if (ptype != NULL) { *ptype = AP_PARAM_FLOAT; } return (AP_Param *)(((token->idx-1)*sizeof(float))+(uintptr_t)PGM_POINTER(&_var_info[i].ptr)); } if (type != AP_PARAM_GROUP) { i++; found_current = true; } for (; i<_num_vars; i++) { type = (enum ap_var_type)PGM_UINT8(&_var_info[i].type); if (type == AP_PARAM_GROUP) { const struct GroupInfo *group_info = (const struct GroupInfo *)PGM_POINTER(&_var_info[i].group_info); AP_Param *ap = next_group(i, group_info, &found_current, 0, 0, token, ptype); if (ap != NULL) { return ap; } } else { // found the next one token->key = i; token->group_element = 0; token->idx = 0; if (ptype != NULL) { *ptype = type; } return (AP_Param *)(PGM_POINTER(&_var_info[i].ptr)); } } return NULL; }
// Find a variable by name in a group AP_Param * AP_Param::find_group(const char *name, uint8_t vindex, const struct GroupInfo *group_info, enum ap_var_type *ptype) { uint8_t type; for (uint8_t i=0; (type=PGM_UINT8(&group_info[i].type)) != AP_PARAM_NONE; i++) { #ifdef AP_NESTED_GROUPS_ENABLED if (type == AP_PARAM_GROUP) { const struct GroupInfo *ginfo = (const struct GroupInfo *)PGM_POINTER(&group_info[i].group_info); AP_Param *ap = find_group(name, vindex, ginfo, ptype); if (ap != NULL) { return ap; } } else #endif // AP_NESTED_GROUPS_ENABLED if (strcasecmp_P(name, group_info[i].name) == 0) { uintptr_t p = PGM_POINTER(&_var_info[vindex].ptr); *ptype = (enum ap_var_type)type; return (AP_Param *)(p + PGM_POINTER(&group_info[i].offset)); } else if (type == AP_PARAM_VECTOR3F) { // special case for finding Vector3f elements uint8_t suffix_len = strnlen_P(group_info[i].name, AP_MAX_NAME_SIZE); if (strncmp_P(name, group_info[i].name, suffix_len) == 0 && name[suffix_len] == '_' && (name[suffix_len+1] == 'X' || name[suffix_len+1] == 'Y' || name[suffix_len+1] == 'Z')) { uintptr_t p = PGM_POINTER(&_var_info[vindex].ptr); AP_Float *v = (AP_Float *)(p + PGM_POINTER(&group_info[i].offset)); *ptype = AP_PARAM_FLOAT; switch (name[suffix_len+1]) { case 'X': return (AP_Float *)&v[0]; case 'Y': return (AP_Float *)&v[1]; case 'Z': return (AP_Float *)&v[2]; } } } } return NULL; }
// Find a object by name. // AP_Param * AP_Param::find_object(const char *name) { for (uint8_t i=0; i<_num_vars; i++) { if (strcasecmp_P(name, _var_info[i].name) == 0) { return (AP_Param *)PGM_POINTER(&_var_info[i].ptr); } } return NULL; }
// load default values for all scalars in a sketch. This does not // recurse into sub-objects void AP_Param::setup_sketch_defaults(void) { setup(); for (uint8_t i=0; i<_num_vars; i++) { uint8_t type = PGM_UINT8(&_var_info[i].type);//返回参数类型,强制转换为uint8,包括PARAM_NONE等 if (type <= AP_PARAM_FLOAT) {//按道理讲uint8_t一定会小于float,这里可能是保护的作用?? void *ptr = (void*)PGM_POINTER(&_var_info[i].ptr);//返回指向参数在内存中位置的指针 set_value((enum ap_var_type)type, ptr, PGM_FLOAT(&_var_info[i].def_value));//把参数变量设为一个特定的值 } } }
// load default values for all scalars in a sketch. This does not // recurse into sub-objects void AP_Param::setup_sketch_defaults(void) { setup(); for (uint8_t i=0; i<_num_vars; i++) { uint8_t type = PGM_UINT8(&_var_info[i].type); if (type <= AP_PARAM_FLOAT) { void *ptr = (void*)PGM_POINTER(&_var_info[i].ptr); set_value((enum ap_var_type)type, ptr, PGM_FLOAT(&_var_info[i].def_value)); } } }
// find the info structure given a header // return the Info structure and a pointer to the variables storage const struct AP_Param::Info *AP_Param::find_by_header(struct Param_header phdr, void **ptr) { // loop over all named variables 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 (key != phdr.key) { // not the right key continue; } if (type != AP_PARAM_GROUP) { // if its not a group then we are done *ptr = (void*)PGM_POINTER(&_var_info[i].ptr); return &_var_info[i]; } const struct GroupInfo *group_info = (const struct GroupInfo *)PGM_POINTER(&_var_info[i].group_info); return find_by_header_group(phdr, ptr, i, group_info, 0, 0); } return NULL; }
// return the first variable in _var_info AP_Param *AP_Param::first(ParamToken *token, enum ap_var_type *ptype) { token->key = 0; token->group_element = 0; token->idx = 0; if (_num_vars == 0) { return NULL; } if (ptype != NULL) { *ptype = (enum ap_var_type)PGM_UINT8(&_var_info[0].type); } return (AP_Param *)(PGM_POINTER(&_var_info[0].ptr)); }
// find the info structure given a header and a group_info table // return the Info structure and a pointer to the variables storage const struct AP_Param::Info *AP_Param::find_by_header_group(struct Param_header phdr, void **ptr, uint8_t vindex, const struct GroupInfo *group_info, uint8_t group_base, uint8_t group_shift) { uint8_t type; for (uint8_t i=0; (type=PGM_UINT8(&group_info[i].type)) != AP_PARAM_NONE; i++) { #ifdef AP_NESTED_GROUPS_ENABLED if (type == AP_PARAM_GROUP) { // a nested group if (group_shift + _group_level_shift >= _group_bits) { // too deeply nested - this should have been caught by // setup() ! return NULL; } const struct GroupInfo *ginfo = (const struct GroupInfo *)PGM_POINTER(&group_info[i].group_info); const struct AP_Param::Info *ret = find_by_header_group(phdr, ptr, vindex, ginfo, GROUP_ID(group_info, group_base, i, group_shift), group_shift + _group_level_shift); if (ret != NULL) { return ret; } continue; } #endif // AP_NESTED_GROUPS_ENABLED if (GROUP_ID(group_info, group_base, i, group_shift) == phdr.group_element) { // found a group element *ptr = (void*)(PGM_POINTER(&_var_info[vindex].ptr) + PGM_UINT16(&group_info[i].offset)); return &_var_info[vindex]; } } return NULL; }
// validate a group info table bool AP_Param::check_group_info(const struct AP_Param::GroupInfo * group_info, uint16_t * total_size, uint8_t group_shift, uint8_t prefix_length) { uint8_t type; int8_t max_idx = -1; for (uint8_t i=0; (type=PGM_UINT8(&group_info[i].type)) != AP_PARAM_NONE; i++) { #ifdef AP_NESTED_GROUPS_ENABLED if (type == AP_PARAM_GROUP) { // a nested group const struct GroupInfo *ginfo = (const struct GroupInfo *)PGM_POINTER(&group_info[i].group_info); if (group_shift + _group_level_shift >= _group_bits) { Debug("double group nesting in %S", group_info[i].name); return false; } if (ginfo == NULL || !check_group_info(ginfo, total_size, group_shift + _group_level_shift, prefix_length + strlen_P(group_info[i].name))) { return false; } continue; } #endif // AP_NESTED_GROUPS_ENABLED uint8_t idx = PGM_UINT8(&group_info[i].idx); if (idx >= (1<<_group_level_shift)) { Debug("idx too large (%u) in %S", idx, group_info[i].name); return false; } if ((int8_t)idx <= max_idx) { Debug("indexes must be in increasing order in %S", group_info[i].name); return false; } max_idx = (int8_t)idx; uint8_t size = type_size((enum ap_var_type)type); if (size == 0) { Debug("invalid type in %S", group_info[i].name); return false; } if (prefix_length + strlen_P(group_info[i].name) > 16) { Debug("suffix is too long in %S", group_info[i].name); return false; } (*total_size) += size + sizeof(struct Param_header); } return true; }
// validate a group info table bool AP_Param::check_group_info(const struct AP_Param::GroupInfo * group_info, uint16_t * total_size, uint8_t group_shift) { uint8_t type; int8_t max_idx = -1; for (uint8_t i=0; (type=PGM_UINT8(&group_info[i].type)) != AP_PARAM_NONE; i++) { #ifdef AP_NESTED_GROUPS_ENABLED if (type == AP_PARAM_GROUP) { // a nested group const struct GroupInfo *ginfo = (const struct GroupInfo *)PGM_POINTER(&group_info[i].group_info); if (group_shift + _group_level_shift >= _group_bits) { // double nesting of groups is not allowed return false; } if (ginfo == NULL || !check_group_info(ginfo, total_size, group_shift + _group_level_shift)) { return false; } continue; } #endif // AP_NESTED_GROUPS_ENABLED uint8_t idx = PGM_UINT8(&group_info[i].idx); if (idx >= (1<<_group_level_shift)) { // passed limit on table size return false; } if ((int8_t)idx <= max_idx) { // the indexes must be in increasing order return false; } max_idx = (int8_t)idx; uint8_t size = type_size((enum ap_var_type)type); if (size == 0) { // not a valid type return false; } (*total_size) += size + sizeof(struct Param_header); } return true; }
// 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; }
// 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; } } // we no longer check if total_size is larger than _eeprom_size, // as we allow for more variables than could fit, relying on not // saving default values return true; }