src/main/fc/settings.c

   1 #include <string.h>
   2 #include <stdint.h>
   3
   4 #include "platform.h"
   5
   6 #include "common/string_light.h"
   7 #include "common/utils.h"
   8
   9 #include "settings_generated.h"
  10
  11 #include "fc/settings.h"
  12
  13 #include "config/general_settings.h"
  14 #include "flight/rpm_filter.h"
  15 #include "settings_generated.c"
  16
  17 static bool settingGetWord(char *buf, int idx)
  18 {
  19         if (idx == 0) {
  20                 return false;
  21         }
  22         const uint8_t *ptr = settingNamesWords;
  23         char *bufPtr = buf;
  24         int used_bits = 0;
  25         int word = 1;
  26         for(;;) {
  27                 int shift = 8 - SETTINGS_WORDS_BITS_PER_CHAR - used_bits;
  28                 char chr;
  29                 if (shift > 0) {
  30                         chr = (*ptr >> shift) & (0xff >> (8 - SETTINGS_WORDS_BITS_PER_CHAR));
  31                 } else {
  32                         chr = (*ptr & (0xff >> (8 - (SETTINGS_WORDS_BITS_PER_CHAR + shift)))) << -shift;
  33                         ptr++;
  34                         chr |= (*ptr) >> (8 + shift);
  35                 }
  36                 if (word == idx) {
  37                         if (chr == 0) {
  38                                 // Finished copying the word
  39                                 *bufPtr++ = '\0';
  40                                 break;
  41                         }
  42                         char c;
  43                         if (chr < 27) {
  44                                 c = 'a' + (chr - 1);
  45                         } else {
  46                                 c = wordSymbols[chr - 27];
  47                         }
  48                         *bufPtr++ = c;
  49                 } else {
  50                         if (chr == 0) {
  51                                 // Word end
  52                                 word++;
  53                         }
  54                 }
  55                 used_bits = (used_bits + SETTINGS_WORDS_BITS_PER_CHAR) % 8;
  56         }
  57         return true;
  58 }
  59
  60 void settingGetName(const setting_t *val, char *buf)
  61 {
  62         uint8_t bpos = 0;
  63         uint16_t n = 0;
  64         char word[SETTING_MAX_WORD_LENGTH];
  65 #ifndef SETTING_ENCODED_NAME_USES_BYTE_INDEXING
  66         uint8_t shift = 0;
  67 #endif
  68         for (uint8_t ii = 0; ii < SETTING_ENCODED_NAME_MAX_BYTES; ii++) {
  69 #ifdef SETTING_ENCODED_NAME_USES_BYTE_INDEXING
  70                 n = val->encoded_name[ii];
  71 #else
  72                 // Decode a variable size uint
  73                 uint16_t b = val->encoded_name[ii];
  74                 if (b >= 0x80) {
  75                         // More bytes follow
  76                         n |= (b&0x7f) << shift;
  77                         shift += 7;
  78                         continue;
  79                 }
  80                 // Final byte
  81                 n |= b << shift;
  82 #endif
  83                 if (!settingGetWord(word, n)) {
  84                         // No more words
  85                         break;
  86                 }
  87                 if (bpos > 0) {
  88                         // Word separator
  89                         buf[bpos++] = '_';
  90                 }
  91                 strcpy(&buf[bpos], word);
  92                 bpos += strlen(word);
  93 #ifndef SETTING_ENCODED_NAME_USES_BYTE_INDEXING
  94                 // Reset shift and n
  95                 shift = 0;
  96                 n = 0;
  97 #endif
  98         }
  99         buf[bpos] = '\0';
 100 }
 101
 102 bool settingNameContains(const setting_t *val, char *buf, const char *cmdline)
 103 {
 104         settingGetName(val, buf);
 105         return strstr(buf, cmdline) != NULL;
 106 }
 107
 108 bool settingNameIsExactMatch(const setting_t *val, char *buf, const char *cmdline, uint8_t var_name_length)
 109 {
 110         settingGetName(val, buf);
 111         return sl_strncasecmp(cmdline, buf, strlen(buf)) == 0 && var_name_length == strlen(buf);
 112 }
 113
 114 const setting_t *settingFind(const char *name)
 115 {
 116         char buf[SETTING_MAX_NAME_LENGTH];
 117         for (int ii = 0; ii < SETTINGS_TABLE_COUNT; ii++) {
 118                 const setting_t *setting = &settingsTable[ii];
 119                 settingGetName(setting, buf);
 120                 if (strcmp(buf, name) == 0) {
 121                         return setting;
 122                 }
 123         }
 124         return NULL;
 125 }
 126
 127 const setting_t *settingGet(unsigned index)
 128 {
 129         return index < SETTINGS_TABLE_COUNT ? &settingsTable[index] : NULL;
 130 }
 131
 132 unsigned settingGetIndex(const setting_t *val)
 133 {
 134         return val - settingsTable;
 135 }
 136
 137 bool settingsValidate(unsigned *invalidIndex)
 138 {
 139         for (unsigned ii = 0; ii < SETTINGS_TABLE_COUNT; ii++) {
 140                 const setting_t *setting = settingGet(ii);
 141                 setting_min_t min = settingGetMin(setting);
 142                 setting_max_t max = settingGetMax(setting);
 143                 void *ptr = settingGetValuePointer(setting);
 144                 bool isValid = false;
 145                 switch (SETTING_TYPE(setting)) {
 146                 case VAR_UINT8:
 147                 {
 148                         uint8_t *value = ptr;
 149                         isValid = *value >= min && *value <= max;
 150                         break;
 151                 }
 152                 case VAR_INT8:
 153                 {
 154                         int8_t *value = ptr;
 155                         isValid = *value >= min && *value <= (int8_t)max;
 156                         break;
 157                 }
 158                 case VAR_UINT16:
 159                 {
 160                         uint16_t *value = ptr;
 161                         isValid = *value >= min && *value <= max;
 162                         break;
 163                 }
 164                 case VAR_INT16:
 165                 {
 166                         int16_t *value = ptr;
 167                         isValid = *value >= min && *value <= (int16_t)max;
 168                         break;
 169                 }
 170                 case VAR_UINT32:
 171                 {
 172                         uint32_t *value = ptr;
 173                         isValid = *value >= (uint32_t)min && *value <= max;
 174                         break;
 175                 }
 176                 case VAR_FLOAT:
 177                 {
 178                         float *value = ptr;
 179                         isValid = *value >= min && *value <= max;
 180                         break;
 181                 }
 182                 case VAR_STRING:
 183                         // We assume all strings are valid
 184                         isValid = true;
 185                         break;
 186                 }
 187                 if (!isValid) {
 188                         if (invalidIndex) {
 189                                 *invalidIndex = ii;
 190                         }
 191                         return false;
 192                 }
 193         }
 194         return true;
 195 }
 196
 197 size_t settingGetValueSize(const setting_t *val)
 198 {
 199         switch (SETTING_TYPE(val)) {
 200                 case VAR_UINT8:
 201                         FALLTHROUGH;
 202                 case VAR_INT8:
 203                         return 1;
 204                 case VAR_UINT16:
 205                         FALLTHROUGH;
 206                 case VAR_INT16:
 207                         return 2;
 208                 case VAR_UINT32:
 209                         FALLTHROUGH;
 210                 case VAR_FLOAT:
 211                         return 4;
 212                 case VAR_STRING:
 213                         return settingGetMax(val);
 214         }
 215         return 0; // Unreachable
 216 }
 217
 218 pgn_t settingGetPgn(const setting_t *val)
 219 {
 220         uint16_t pos = val - (const setting_t *)settingsTable;
 221         uint16_t acc = 0;
 222         for (uint8_t ii = 0; ii < SETTINGS_PGN_COUNT; ii++) {
 223                 acc += settingsPgnCounts[ii];
 224                 if (acc > pos) {
 225                         return settingsPgn[ii];
 226                 }
 227         }
 228         return -1;
 229 }
 230
 231 static uint16_t getValueOffset(const setting_t *value)
 232 {
 233     switch (SETTING_SECTION(value)) {
 234     case MASTER_VALUE:
 235         return value->offset;
 236     case PROFILE_VALUE:
 237         return value->offset + sizeof(pidProfile_t) * getConfigProfile();
 238     case CONTROL_RATE_VALUE:
 239         return value->offset + sizeof(controlRateConfig_t) * getConfigProfile();
 240         case EZ_TUNE_VALUE:
 241                 return value->offset + sizeof(ezTuneSettings_t) * getConfigProfile();
 242     case BATTERY_CONFIG_VALUE:
 243         return value->offset + sizeof(batteryProfile_t) * getConfigBatteryProfile();
 244         case MIXER_CONFIG_VALUE:
 245         return value->offset + sizeof(mixerProfile_t) * getConfigMixerProfile();
 246     }
 247     return 0;
 248 }
 249
 250 void *settingGetValuePointer(const setting_t *val)
 251 {
 252     const pgRegistry_t *pg = pgFind(settingGetPgn(val));
 253     return pg->address + getValueOffset(val);
 254 }
 255
 256 const void * settingGetCopyValuePointer(const setting_t *val)
 257 {
 258     const pgRegistry_t *pg = pgFind(settingGetPgn(val));
 259     return pg->copy + getValueOffset(val);
 260 }
 261
 262 setting_min_t settingGetMin(const setting_t *val)
 263 {
 264         if (SETTING_MODE(val) == MODE_LOOKUP) {
 265                 return 0;
 266         }
 267         return settingMinMaxTable[SETTING_INDEXES_GET_MIN(val)];
 268 }
 269
 270 setting_max_t settingGetMax(const setting_t *val)
 271 {
 272         if (SETTING_MODE(val) == MODE_LOOKUP) {
 273                 return settingLookupTables[val->config.lookup.tableIndex].valueCount - 1;
 274         }
 275         return settingMinMaxTable[SETTING_INDEXES_GET_MAX(val)];
 276 }
 277
 278 const lookupTableEntry_t * settingLookupTable(const setting_t *val)
 279 {
 280         if (SETTING_MODE(val) == MODE_LOOKUP && val->config.lookup.tableIndex < LOOKUP_TABLE_COUNT) {
 281                 return &settingLookupTables[val->config.lookup.tableIndex];
 282         }
 283         return NULL;
 284 }
 285
 286 const char * settingLookupValueName(const setting_t *val, unsigned v)
 287 {
 288         const lookupTableEntry_t *table = settingLookupTable(val);
 289         if (table && v < table->valueCount) {
 290                 return table->values[v];
 291         }
 292         return NULL;
 293 }
 294
 295 size_t settingGetValueNameMaxSize(const setting_t *val)
 296 {
 297         size_t maxSize = 0;
 298         const lookupTableEntry_t *table = settingLookupTable(val);
 299         if (table) {
 300                 for (unsigned ii = 0; ii < table->valueCount; ii++) {
 301                         maxSize = MAX(maxSize, strlen(table->values[ii]));
 302                 }
 303         }
 304         return maxSize;
 305 }
 306
 307 const char * settingGetString(const setting_t *val)
 308 {
 309         if (SETTING_TYPE(val) == VAR_STRING) {
 310                 return settingGetValuePointer(val);
 311         }
 312         return NULL;
 313 }
 314
 315 void settingSetString(const setting_t *val, const char *s, size_t size)
 316 {
 317         if (SETTING_TYPE(val) == VAR_STRING) {
 318                 char *p = settingGetValuePointer(val);
 319                 size_t copySize = MIN(size, settingGetMax(val));
 320                 memcpy(p, s, copySize);
 321                 p[copySize] = '\0';
 322         }
 323 }
 324
 325 setting_max_t settingGetStringMaxLength(const setting_t *val)
 326 {
 327         if (SETTING_TYPE(val) == VAR_STRING) {
 328                 // Max string length is stored as its max
 329                 return settingGetMax(val);
 330         }
 331         return 0;
 332 }
 333
 334 bool settingsGetParameterGroupIndexes(pgn_t pg, uint16_t *start, uint16_t *end)
 335 {
 336         unsigned acc = 0;
 337         for (int ii = 0; ii < SETTINGS_PGN_COUNT; ii++) {
 338                 if (settingsPgn[ii] == pg) {
 339                         if (start) {
 340                                 *start = acc;
 341                         }
 342                         if (end) {
 343                                 *end = acc + settingsPgnCounts[ii] - 1;
 344                         }
 345                         return true;
 346                 }
 347                 acc += settingsPgnCounts[ii];
 348         }
 349         return false;
 350 }