int set_age(int age)
{
  if (age>=0 && age <=100)
  {
    local_age = age;
    return 0;
  }

  perror("incorrect age!");
  return -1;
}

enum ParamType {
paramInt,
paramUint,
paramFloat,
paramBytes,
};

// Поток для чтения и записи значений
// В простейшем случае это просто буфер, размер и тип значения в буфере
// Если параметр может иметь несколько значений, то придется усложнить (скажем сделать односвязный список таких структур)
// Если хочется иметь возможность делать произвольные действия (писать/читать сразу в формате протокола и т.п.), то тут должны быть указатели на функции
struct ParamStream {
void *buf;
uint16_t size;
ParamType type;
bool error; // произошла ошибка чтения/записи?
};

// это интерфейс к ParamStream, который позволяет читать/писать значение
// конкретная реализация зависит от вида ParamStream
uint8_t paramStream_readUI8(ParamStream *s) {
// конвертирует содержимое потока в uint8_t; если это невозможно - устанавливает s->error
}
uint16_t paramStream_readUI16(ParamStream *s);
...
uint16_t paramStream_readBytes(ParamStream *s, byte *buf, byte bufSize);

void paramStream_writeUI8(ParamStream *s, uint8_t v);
...
void paramStream_writeBytes(ParamStream *s, const byte *buf, byte bufSize);


enum ParamResult {
parres_OK,
parres_BadValue,
parres_NoParam,
parres_NoAction,
...
};

enum ParamAction {
paract_Get,
paract_Set,
paract_Check, // проверить значение на допустимость без установки - бывает полезно в меню
};

typedef ParamResult (*ParamAccessor)(ParamStream *s, ParamAction act);

struct ParamInfo {
uint16_t code;
ParamAccessor accessor;
};

/// Эта функция для пользователей данной системы. Она ищет в глобальном массиве ParamInfo параметр с данным кодом (бинарный поиск к примеру) и вызывает его accessor
ParamResult paramAccessor(uint16_t code, ParamStream *s, ParamAction act);

// получить значение параметра 42
unsigned value;
ParamStream stream = {.buf=&value, .size = sizeof(value), .type=paramUint};
paramAccessor(42, &stream, paract_Get);

// установить значение параметра 55
byte buf[10] = {1, 2, 3};
ParamStream stream = {.buf=&buf, .size = sizeof(buf), .type=paramBytes};
paramAccessor(55, &stream, paract_Set);

int a, b;

// вычисляемый параметр только для чтения
ParamResult  param_42(ParamStream *s, ParamAction act) {
  switch(act) {
  case paract_Get: paramStream_writeUI8(s, a+b); return parres_OK;
  default: return parres_NoAction;
  }
}

byte buf[20];

// чтение/запись
ParamResult  param_55(ParamStream *s, ParamAction act) {
  switch(act) {
  case paract_Get: paramStream_writeBytes(s, buf, 20); return parres_OK;
  case paract_Set: paramStream_readBytes(s, buf, 20); return parres_OK;
  default: return parres_NoAction;
  }
}

ParamInfo paramInfo[] = {
  {42, param_42},
  {55, param_55},
  {0, 0} // терминатор

bool cfg_editor::do_edit(bool from_last)
{
    // return true to edit field
    auto always            = [](cfg_cache &)     { return true; };
    auto dhcp_disabled     = [](cfg_cache & cfg) { return cfg->Localhost.DHCP_enabled == false; };


    struct
    {
        bool (*is_item_active)(cfg_cache &);
        cfg_editor_ui::result (*function)(cfg_editor *);
    } const Table[] =
    {
    #define HANDLER(edit_func, param_name, ...)  [](cfg_editor * editor) { return editor-> edit_func (param_name , editor->Cfg-> __VA_ARGS__); }
        { always,         HANDLER(edit_MAC,       "MAC address    ",                          Localhost.MAC_address) },
        { always,         HANDLER(choose_YN,      "DHCP enabled "  ,                          Localhost.DHCP_enabled) },
        { dhcp_disabled,  HANDLER(edit_IP,        "IP address     ",                          Localhost.IP_address.addr) },
        { dhcp_disabled,  HANDLER(edit_IP,        "Netmask        ",                          Localhost.Netmask.addr) },
        { dhcp_disabled,  HANDLER(edit_IP,        "Gateway        ",                          Localhost.Gateway.addr) },
#if LWIP_DNS
        { dhcp_enabled,   HANDLER(edit_IP,        "DNS1           ",                          Localhost.DNS[0].addr) },
        { dhcp_enabled,   HANDLER(edit_IP,        "DNS2           ",                          Localhost.DNS[1].addr) },
#endif
        { always,         HANDLER(edit,           "Hostname       ",                          Localhost.Hostname) },

        { always,         HANDLER(edit,           "Telnet port    ",                          Telnet.Port) },
        { always,         HANDLER(edit_password,  "Telnet password (space = disabled)",       Telnet.Password) },

        { always,         HANDLER(edit,           "Serial port baudrate   ",          Serial.Baudrate, 600, 115200) },
        .........
    };

    size_t const Last_index = sizeof(Table) / sizeof(Table[0]) - 1;
    size_t Index = from_last ? Last_index : 0;

    for(;;)
    {
        Console.new_line();
    Repeat:
        switch(Table[Index].function(this))
        {
        case result::CONSOLE_CLOSED:
        case result::TIMEOUT:
            return false;

        case result::ABORTED:
            return true;

        case result::KEY_UP:
            if(Index == 0)
            {
                Console.send('\r');
                goto Repeat;
            }
            while(--Index && !Table[Index].is_item_active(Cfg))
               ;
            break;

        case result::JUST_ENTER:
        case result::OK:
            if(Index == Last_index)
                return true;
            while(++Index < Last_index && !Table[Index].is_item_active(Cfg))
               ;

            if(!Table[Index].is_item_active(Cfg))   // if last item inactive
                return true;
            break;

        case result::KEY_DOWN:
            if(Index == Last_index)
            {
                Console.send('\r');
                goto Repeat;
            }
            while(++Index < Last_index && !Table[Index].is_item_active(Cfg))
               ;
            // last index inactive, go back to active
            if(Index == Last_index && !Table[Index].is_item_active(Cfg))
            {
                while(--Index && !Table[Index].is_item_active(Cfg))
                   ;
                Console.send('\r');
                goto Repeat;

            }
            break;
        }
    }
    return true;    // make eclipse parser happy
}

#define    HALLS_CHANNELS_QTY    2

typedef struct
{    int             position;
    unsigned char    cur;                //current_inputs;
    unsigned char    prev;            //previous_inputs
    unsigned char    prev_prev;        //before previous inputs
    unsigned char    init;
}    hall_type;

extern hall_type hall[HALLS_CHANNELS_QTY];
extern hall_type old_hall[HALLS_CHANNELS_QTY];