menu.c

/*
    menu - handle showing to display, menus for basic channel settings
    Copyright (C) 2011 Pavel Semerad

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/



#include <string.h>
#include "menu.h"
#include "config.h"
#include "calc.h"
#include "timer.h"
#include "ppm.h"
#include "lcd.h"
#include "buzzer.h"
#include "input.h"






// variables to be used in CALC task
u8  menu_force_value_channel;	// set PPM value for this channel
s16 menu_force_value;		//   to this value (-500..500)






// flags for wakeup after each ADC measure
_Bool menu_adc_wakeup;
// don't stop main loop and check keys
u8 menu_check_keys;
// temporary flag used when doing reset (global/all models/model)
_Bool menu_tmp_flag;







// show model number, extra function to handle more than 10 models
static void show_model_number(u8 model) {
    lcd_7seg((u8)(model % 10));
    lcd_segment(LS_SYM_RIGHT, (u8)((u8)(model / 10) & 1));
    lcd_segment(LS_SYM_LEFT, (u8)((u8)(model / 20) & 1));
    lcd_segment(LS_SYM_PERCENT, (u8)((u8)(model / 40) & 1));
    lcd_segment(LS_SYM_MODELNO, LS_ON);
}


// show main screen (model number and name/battery/...)
static void main_screen(u8 item) {
    menu_adc_wakeup = 0;

    // chars is item dependent
    if (item == MS_NAME) {
	// model name
	lcd_segment(LS_SYM_CHANNEL, LS_OFF);
	lcd_segment(LS_SYM_DOT, LS_OFF);
	lcd_segment(LS_SYM_VOLTS, LS_OFF);
	show_model_number(cg.model);
	lcd_chars(cm.name);
    }
    else if (item == MS_BATTERY) {
	static u16 bat_val;
	static u16 bat_time;

	// battery voltage
	lcd_segment(LS_SYM_CHANNEL, LS_OFF);
	lcd_segment(LS_SYM_DOT, LS_ON);
	lcd_segment(LS_SYM_VOLTS, LS_ON);
	show_model_number(cg.model);
	// calculate voltage from current raw value and calib value
	if (time_sec >= bat_time) {
	    bat_time = time_sec + 2;
	    bat_val = (u16)(((u32)adc_battery * 100 + 300) / cg.battery_calib);
	}
	lcd_char_num3(bat_val);
	menu_adc_wakeup = 1;
    }
    else {
	// timers
	menu_timer_show((u8)(item - MS_TIMER0));
    }
    lcd_update();
}






// common menu processing, selecting channel and then changing values
#define menu_adc_direction	menu_tmp_flag
// channel if from 0
static void menu_set_adc_direction(u8 channel) {
    u16 adc, calm;

    // for channel 2 use throttle, for others steering
    if (channel == 1) {
	adc = adc_throttle_ovs;
	calm = cg.calib_throttle_mid;
    }
    else {
	adc = adc_steering_ovs;
	calm = cg.calib_steering_mid;
    }

    // check steering firstly
    if (adc_steering_ovs < ((cg.calib_steering_mid - 40) << ADC_OVS_SHIFT))
	menu_adc_direction = 0;
    else if (adc_steering_ovs > ((cg.calib_steering_mid + 40) << ADC_OVS_SHIFT))
	menu_adc_direction = 1;

    // then check throttle
    if (adc_throttle_ovs < ((cg.calib_throttle_mid - 40) << ADC_OVS_SHIFT))
	menu_adc_direction = 0;
    else if (adc_throttle_ovs > ((cg.calib_throttle_mid + 40) << ADC_OVS_SHIFT))
	menu_adc_direction = 1;

    // and then CH3 button
    else if (btn(BTN_CH3))  menu_adc_direction ^= 1;

    // if this channel is using forced values, set it to left/right
    if (menu_force_value_channel)
	menu_force_value = menu_adc_direction ? PPM(500) : PPM(-500);
}

// channel if from 0
static void menu_set_adc_force(u8 channel, u8 use_adc, u8 force_values) {
    // check if force servos to positions (left/center/right)
    if ((u8)(force_values & (u8)(1 << channel))) {
	menu_force_value_channel = (u8)(channel + 1);
	menu_force_value = 0;	// to center by default
    }
    else menu_force_value_channel = 0;

    // check use of ADC
    if ((u8)(use_adc & (u8)(1 << channel))) {
	menu_adc_wakeup = 1;
	menu_set_adc_direction(channel);
    }
    // don't use ADC
    else  menu_adc_wakeup = 0;
}

typedef void (*menu_channel_subfunc_t)(u8, u8);
typedef struct {
    u8 end_channel;
    u8 use_adc;
    u8 forced_values;
    menu_channel_subfunc_t func;
    u8 last_direction;
} menu_channel_t;

static void menu_channel_func(u8 action, menu_channel_t *p) {
    switch (action) {
	case MCA_INIT:
	    menu_set_adc_force(menu_id, p->use_adc, p->forced_values);
	    break;
	case MCA_SET_CHG:
	    p->func(menu_id, 1);
	    break;
	case MCA_ID_CHG:
	    menu_id = (u8)menu_change_val(menu_id, 0, p->end_channel - 1, 1, 1);
	    menu_set_adc_force(menu_id, p->use_adc, p->forced_values);
	    break;
	case MCA_ADC_PRE:
	    menu_set_adc_direction(menu_id);
	    return;	// show nothing at ADC_PRE
	case MCA_ADC_POST:
	    // do nothing if left-right didn't changed
	    if (p->last_direction == menu_adc_direction)  return;
	    // else flag it to show value
	    menu_id_set = 1;	// flag that new value is showed
	    return;
    }

    // show value
    lcd_segment(LS_SYM_CHANNEL, LS_ON);
    if (action != MCA_SET_CHG) {  // already showed
	lcd_7seg((u8)(menu_id + 1));
	p->func(menu_id, 0);
    }
    if (menu_adc_wakeup) {
	// show arrow
	if (menu_adc_direction)
	    lcd_segment(LS_SYM_RIGHT, LS_ON);
	else
	    lcd_segment(LS_SYM_LEFT, LS_ON);
    }
    p->last_direction = menu_adc_direction;
}

static void menu_channel(u8 end_channel, u8 use_adc, u8 forced_values,
			 menu_channel_subfunc_t subfunc) {
    menu_channel_t p;
	p.end_channel = end_channel;
	p.use_adc = use_adc;
	p.forced_values = forced_values;
	p.func = subfunc;
    menu_adc_direction = 0;

    menu_common(menu_channel_func, &p, MCF_NONE);
    config_model_save();
}







// *************************** MODEL MENUS *******************************

// select model/save model as (to selected model position)
#define MIN(a, b)  (a < b ? a : b)
static void menu_model_func(u8 action, u8 *model) {
    if (action == MCA_ID_CHG)
	*model = (u8)menu_change_val((s16)*model, 0,
				     MIN(CONFIG_MODEL_MAX, 80) - 1,
				     MODEL_FAST, 1);

    show_model_number(*model);
    lcd_chars(config_model_name(*model));
}

static void menu_model(u8 saveas) {
    u8 model = cg.model;

    if (saveas)  lcd_set_blink(LMENU, LB_SPC);

    menu_common(menu_model_func, &model, MCF_ENTER);

    // if new model choosed, save it
    if (model != cg.model) {
	config_set_model(model);
	if (saveas) {
	    // save to new model position
	    config_model_save();
	}
	else {
	    // load selected model
	    menu_load_model();
	}
    }
    if (saveas)  lcd_set_blink(LMENU, LB_OFF);
}


// change model name
static void menu_name_func(u8 action, void *p) {
    u8 letter;

    if (action == MCA_SET_CHG) {
	// change letter
	letter = cm.name[menu_set];
	if (btn(BTN_ROT_L)) {
	    // lower
	    if (letter == '0')      letter = 'Z';
	    else if (letter == 'A')	letter = '9';
	    else                    letter--;
	}
	else {
	    // upper
	    if (letter == '9')      letter = 'A';
	    else if (letter == 'Z')	letter = '0';
	    else                    letter++;
	}
	cm.name[menu_set] = letter;
    }
    else if (action == MCA_SET_NEXT) {
	// next char
	if (++menu_set > 2)  menu_set = 0;
    }

    // show name
    menu_blink = (u8)(1 << menu_set);	// blink only selected char
    show_model_number(cg.model);
    lcd_chars(cm.name);
}

static void menu_name(void) {
    menu_common(menu_name_func, NULL, MCF_SET_ONLY);
    config_model_save();
}


// set number of model channels
static void menu_channels(u8 action) {
    // change value
    if (action == MLA_CHG)
	cm.channels = (u8)(menu_change_val(cm.channels + 1, 2,
					   MAX_CHANNELS, 1, 0) - 1);

    // show value
    lcd_7seg(L7_C);
    lcd_segment(LS_SYM_CHANNEL, LS_ON);
    lcd_char_num3(cm.channels + 1);
}

// reset model to defaults
static void menu_reset_model(u8 action) {
    // change value
    if (action == MLA_CHG)  menu_tmp_flag ^= 1;

    // select next value, reset when flag is set
    else if (action == MLA_NEXT) {
	if (menu_tmp_flag) {
	    menu_tmp_flag = 0;
	    config_model_set_default();
	    buzzer_on(60, 0, 1);
	}
    }

    // show value
    lcd_7seg(L7_R);
    lcd_chars(menu_tmp_flag ? "YES" : "NO ");
}

static const menu_list_t chanres_funcs[] = {
    menu_channels,
    menu_reset_model,
};

// set number of model channels, reset model to default values
static void menu_channels_reset(void) {
    menu_tmp_flag = 0;
    lcd_set_blink(LMENU, LB_SPC);
    menu_list(chanres_funcs, sizeof(chanres_funcs) / sizeof(void *), MCF_NONE);
    lcd_set_blink(LMENU, LB_OFF);
    config_model_save();
    apply_model_config();
}


// set reverse
void sf_reverse(u8 channel, u8 change) {
    u8 bit = (u8)(1 << channel);
    if (change)  cm.reverse ^= bit;
    if (cm.reverse & bit)  lcd_chars("REV");
    else                   lcd_chars("NOR");
}
@inline static void menu_reverse(void) {
    menu_channel(channels, 0, 0, sf_reverse);
}


// set endpoints
void sf_endpoint(u8 channel, u8 change) {
    u8 *addr = &cm.endpoint[channel][menu_adc_direction];
    if (change)  *addr = (u8)menu_change_val(*addr, 0, cg.endpoint_max,
                                             ENDPOINT_FAST, 0);
    lcd_segment(LS_SYM_PERCENT, LS_ON);
    lcd_char_num3(*addr);
}
@inline static void menu_endpoint(void) {
    menu_channel(channels, 0xff, 0xfc, sf_endpoint);
}


// set trims
static void sf_trim(u8 channel, u8 change) {
    s8 *addr = &cm.trim[channel];
    if (change)  *addr = (s8)menu_change_val(*addr, -TRIM_MAX, TRIM_MAX,
                                             TRIM_FAST, 0);
    if (channel == 0)  lcd_char_num2_lbl(*addr, "LNR");
    else               lcd_char_num2_lbl(*addr, "FNB");
}
@inline static void menu_trim(void) {
    menu_channel(2, 0, 0, sf_trim);
}


// set subtrims
static void sf_subtrim(u8 channel, u8 change) {
    s8 *addr = &cm.subtrim[channel];
    if (change)
	*addr = (s8)menu_change_val(*addr, -SUBTRIM_MAX, SUBTRIM_MAX,
	                            SUBTRIM_FAST, 0);
    lcd_char_num3(*addr);
}
static void menu_subtrim(void) {
    lcd_set_blink(LMENU, LB_SPC);
    menu_channel(channels, 0, 0xfc, sf_subtrim);
    lcd_set_blink(LMENU, LB_OFF);
}


// set dualrate
static void sf_dualrate(u8 channel, u8 change) {
    u8 *addr = &cm.dualrate[channel];
    if (channel == 1 && menu_adc_direction)  addr = &cm.dualrate[2];
    if (change)  *addr = (u8)menu_change_val(*addr, 0, 100, DUALRATE_FAST, 0);
    lcd_segment(LS_SYM_PERCENT, LS_ON);
    lcd_char_num3(*addr);
}
@inline static void menu_dualrate(void) {
    menu_channel(2, 0x2, 0, sf_dualrate);
}


// set servo speed
static void sf_speed(u8 channel, u8 change) {
    u8 *addr = &cm.speed[channel];
    u8 thfwdonly = (u8)(channel == 1 && menu_adc_direction ? 1 : 0);
    if (channel == 0 && menu_adc_direction)  addr = &cm.stspd_return;
    if (change) {
	if (thfwdonly)
	    // throttle forward only setting
	    cm.thspd_onlyfwd ^= 1;
	else *addr = (u8)menu_change_val(*addr, 1, 100, SPEED_FAST, 0);
    }
    if (thfwdonly)
	lcd_chars(cm.thspd_onlyfwd ? "OFF" : "ON ");
    else {
	lcd_char_num3(*addr);
	lcd_segment(LS_SYM_PERCENT, LS_ON);
    }
}
static void menu_speed(void) {
    lcd_set_blink(LMENU, LB_SPC);
    menu_channel(channels, 0x3, 0, sf_speed);
    lcd_set_blink(LMENU, LB_OFF);
}


// set expos
static void sf_expo(u8 channel, u8 change) {
    s8 *addr = &cm.expo[channel];
    if (channel == 1 && menu_adc_direction)  addr = &cm.expo[2];
    if (change)  *addr = (s8)menu_change_val(*addr, -EXPO_MAX, EXPO_MAX,
                                             EXPO_FAST, 0);
    lcd_segment(LS_SYM_PERCENT, LS_ON);
    lcd_char_num3(*addr);
}
@inline static void menu_expo(void) {
    menu_channel(2, 0x2, 0, sf_expo);
}


// set channel value, exclude 4WS and DIG channels
//   for channels 3..8 so add 2 to channel number
static void sf_channel_val(u8 channel, u8 change) {
    s8 *addr = &menu_channel3_8[channel];
    if (change && !(menu_channels_mixed & (u8)(1 << (channel + 2))))
	*addr = (s8)menu_change_val(*addr, -100, 100, CHANNEL_FAST, 0);

    // show value
    lcd_7seg((u8)(channel + 2 + 1));
    lcd_char_num3(*addr);
}
static void menu_channel_value(void) {
    if (channels < 3)  return;
    lcd_set_blink(LMENU, LB_SPC);
    menu_channel((u8)(channels - 2), 0, 0, sf_channel_val);
    lcd_set_blink(LMENU, LB_OFF);
}


// set abs: OFF, SLO(6), NOR(4), FAS(3)
// pulses between full brake and 1/2 brake and only when enought brake applied
static const u8 abs_labels[][4] = {
    "OFF", "SLO", "NOR", "FAS"
};
#define ABS_LABEL_SIZE  (sizeof(abs_labels) / 4)

static void menu_abs_func(u8 action, void *p) {
    // change value
    if (action == MCA_SET_CHG)
	cm.abs_type = (u8)menu_change_val(cm.abs_type, 0, ABS_LABEL_SIZE-1, 1, 1);
    
    // show value
    lcd_segment(LS_SYM_CHANNEL, LS_ON);
    lcd_7seg(2);
    lcd_chars(abs_labels[cm.abs_type]);
}

static void menu_abs(void) {
    menu_common(menu_abs_func, NULL, (u8)(MCF_ENTER | MCF_SET_ONLY));
    config_model_save();
}







// choose from menu items
static void select_menu(void) {
    u8 menu = LM_MODEL;
    lcd_menu(menu);
    main_screen(MS_NAME);	// show model number and name

    while (1) {
	btnra();
	menu_stop();

	// Back/End key to end this menu
	if (btn(BTN_BACK | BTN_END))  break;

	// Enter key - goto submenu
	if (btn(BTN_ENTER)) {
	    key_beep();
	    if (menu == LM_MODEL) {
		if (btnl(BTN_ENTER))	menu_model(1);
		else {
					menu_model(0);
					break;
		}
	    }
	    else if (menu == LM_NAME) {
		if (btnl(BTN_ENTER))	menu_channels_reset();
		else			menu_name();
	    }
	    else if (menu == LM_REV) {
		if (btnl(BTN_ENTER))	menu_key_mapping();
		else			menu_reverse();
	    }
	    else if (menu == LM_EPO) {
		if (btnl(BTN_ENTER))	menu_mix();
		else			menu_endpoint();
	    }
	    else if (menu == LM_TRIM) {
		if (btnl(BTN_ENTER))	menu_subtrim();
		else			menu_trim();
	    }
	    else if (menu == LM_DR) {
		if (btnl(BTN_ENTER))	menu_speed();
		else			menu_dualrate();
	    }
	    else if (menu == LM_EXP) {
		if (btnl(BTN_ENTER))	menu_channel_value();
		else			menu_expo();
	    }
	    else {
		if (btnl(BTN_ENTER))	break;
		else			menu_abs();
	    }
	    main_screen(MS_NAME);	// show model number and name
	    // exit when BACK
	    if (btn(BTN_BACK))  break;
	}

	// rotate keys
	else if (btn(BTN_ROT_ALL)) {
	    if (btn(BTN_ROT_R)) {
		menu >>= 1;
		if (!menu)  menu = LM_MODEL;
	    }
	    else {
		menu <<= 1;
		if (!menu)  menu = LM_ABS;
	    }
	    lcd_menu(menu);
	    lcd_update();
	}
    }

    key_beep();
    lcd_menu(0);
}








// ****************** MAIN LOOP and init *********************************

// main menu loop, shows main screen and handle keys
u8 menu_main_screen;
static void menu_loop(void) {
    menu_main_screen = MS_NAME;

    lcd_clear();

    while (1) {
	if (!menu_check_keys) {
	    main_screen(menu_main_screen);
	    btnra();
	    menu_stop();
	}
	else  menu_check_keys = 0;

	// don't wanted in submenus, will be set back in main_screen()
	menu_adc_wakeup = 0;
	menu_timer_wakeup = 0;

	// Enter long key - global/calibrate/key-test
	if (btnl(BTN_ENTER)) {
	    if (menu_main_screen >= MS_TIMER0) {
		key_beep();
		menu_timer_lap_times((u8)(menu_main_screen - MS_TIMER0));
		btnra();
	    }
	    else if (adc_steering_ovs > (CALIB_ST_MID_HIGH << ADC_OVS_SHIFT))
		menu_calibrate(0);
	    else if (adc_steering_ovs < (CALIB_ST_LOW_MID << ADC_OVS_SHIFT))
		menu_key_test();
	    else menu_global_setup();
	}

	// Enter key - menu
	else if (btn(BTN_ENTER)) {
	    key_beep();
	    if (menu_main_screen >= MS_TIMER0)
		menu_timer_setup((u8)(menu_main_screen - MS_TIMER0));
	    else select_menu();
	    btnra();
	}

	// electronic trims
	else if (menu_electronic_trims())
	    menu_check_keys = 1;

	// buttons (CH3, Back, End)
	else if (menu_buttons())
	    menu_check_keys = 1;

	// rotate encoder - change model name/battery/...
	else if (btn(BTN_ROT_ALL))
	    menu_main_screen =
		(u8)menu_change_val(menu_main_screen, 0, MS_MAX - 1, 1, 1);
    }
}



// read config from eeprom, initialize and call menu loop
void menu_init(void) {
    // variables
    menu_key_mapping_prepare();

    // wait for some time to read ADC/buttons several times and get
    //   stable values
    while (time_sec == 0 && time_5ms < 10)  pause();

    // read global config from eeprom, if calibrate values was set to defaults,
    //   call calibrate
    if (config_global_read()) {
	menu_calibrate(1);
	btnra();
	reset_inactivity_timer();
    }
    else {
	u16 steering = ADC_OVS(steering);
	u16 throttle = ADC_OVS(throttle);

	apply_global_config();
	reset_inactivity_timer();

	// if actual steering/throttle value is not in dead zone, beep 3 times
	if (cg.poweron_warn &&
	    (steering < (cg.calib_steering_mid - cg.steering_dead_zone) ||
	     steering > (cg.calib_steering_mid + cg.steering_dead_zone) ||
	     throttle < (cg.calib_throttle_mid - cg.throttle_dead_zone) ||
	     throttle > (cg.calib_throttle_mid + cg.throttle_dead_zone)))
		    buzzer_on(30, 30, 3);
	// else beep 1 times
	else if (cg.poweron_beep)  beep(30);
    }

    // reset global timers
    menu_timer_clear(0, 1);
    menu_timer_clear(1, 1);

    // read model config from eeprom
    menu_load_model();

    // and main loop
    menu_loop();
}