Exemple #1
0
void gui_value_irqh(uint8_t type, uint8_t * buff)
{
	float tmp;

	switch (gui_value_type)
	{
	case(GUI_VAL_NUMBER):
	case(GUI_VAL_NUMBER_DISABLE):
		gui_value_number_irqh(type, buff);
	break;

	case(GUI_VAL_TIME):
		gui_value_time_irqh(type, buff);
	break;

	case(GUI_VAL_DATE):
		gui_value_date_irqh(type, buff);
	break;

	case(GUI_VAL_CONTRAST):
		gui_value_number_irqh(type, buff);
		config.gui.contrast = gui_value_tmp;
		gui_change_disp_cfg();
	break;

	case(GUI_VAL_BRIGTHNES):
		gui_value_number_irqh(type, buff);
		config.gui.brightness = gui_value_tmp;
	break;

	case(GUI_VAL_VARIO_TEST):
		gui_value_number_irqh(type, buff);
		gui_value_tmp = round(gui_value_tmp * 10) / 10;

		audio_demo_val = gui_value_tmp;
	break;

	case(GUI_VAL_VOLUME):
		tmp = gui_value_tmp;
		gui_value_number_irqh(type, buff);

		//only when there is a change in volume
		if (gui_value_tmp != tmp)
		{
			uint8_t vol = gui_value_tmp;
			seq_start(&audio_feedback, vol);
		}
	break;
	}

}
Exemple #2
0
void gui_list_draw()
{
	char tmp_text[64];
	char tmp_sub_text[32];

	uint8_t flags;

	disp.LoadFont(F_TEXT_M);
	uint8_t t_h = disp.GetTextHeight();

	int16_t y = gui_list_y_offset;
	int8_t height;
	int16_t total_height = 0;
	uint8_t sub_height;

	//emulate middle click
	if (button_in_reset(B_MIDDLE))
	{
		if (task_get_ms_tick() - gui_list_middle_hold > BUTTON_LONG)
		{
			gui_switch_task(gui_list_back);
			if (config.gui.menu_audio_flags & CFG_AUDIO_MENU_BUTTONS && gui_buttons_override == false)
				seq_start(&snd_menu_exit, config.gui.menu_volume);
		}
	}
	else
		gui_list_middle_hold = task_get_ms_tick();

	for (uint8_t i = 0; i < gui_list_size; i++)
	{
		height = 1 + t_h;

		flags = 0;
		if (i < gui_list_size - 1)
		{
			gui_list_gen_f(i, tmp_text, &flags, tmp_sub_text);
		}
		else
		{
			strcpy_P(tmp_text, PSTR("back"));
			flags = GUI_LIST_BACK;
		}

		uint8_t x_val = 5;

		switch(flags & GUI_LIST_T_MASK)
		{
			case(GUI_LIST_FOLDER):
				x_val = 5;
			break;

			case(GUI_LIST_BACK):
				x_val = 2;
			break;
		}

		if ((flags & GUI_LIST_T_MASK) == GUI_LIST_SUB_TEXT)
		{
			sub_height = disp.GetTextHeight();
			height += sub_height;
		}

		if (gui_list_index[gui_task] == i)
		{
			if (y < 0)
				gui_list_y_offset = -total_height;

			if (y > GUI_DISP_HEIGHT - height)
				gui_list_y_offset = -total_height + GUI_DISP_HEIGHT - height;
		}

		if (y > GUI_DISP_HEIGHT)
			continue;

		disp.GotoXY(x_val, y + 1);
		fprintf_P(lcd_out, PSTR("%s"), tmp_text);

		//sub text
		if ((flags & GUI_LIST_T_MASK) == GUI_LIST_SUB_TEXT)
			gui_raligh_text(tmp_sub_text, GUI_DISP_WIDTH - 3, y + t_h + 1);

		//tick
		if ((flags & GUI_LIST_T_MASK) == GUI_LIST_CHECK_OFF || (flags & GUI_LIST_T_MASK) == GUI_LIST_CHECK_ON)
		{
			disp.DrawRectangle(GUI_DISP_WIDTH - 9, y + 1, GUI_DISP_WIDTH - 3, y + 7, 1, 0);
			if ((flags & GUI_LIST_T_MASK) == GUI_LIST_CHECK_ON)
			{
				disp.DrawLine(GUI_DISP_WIDTH - 8, y + 5, GUI_DISP_WIDTH - 7, y + 6, 1);
				disp.DrawLine(GUI_DISP_WIDTH - 6, y + 5, GUI_DISP_WIDTH - 4, y + 3, 1);
			}
		}

		if (flags & GUI_LIST_DISABLED)
		{
			for (uint8_t cx = 0; cx < GUI_DISP_WIDTH - 1; cx++)
				for (uint8_t cy = y + cx % 2 + 1; cy < y + t_h; cy += 2)
					disp.PutPixel(cx, cy, 0);
		}

		if (gui_list_index[gui_task] == i)
		{
			disp.Invert(0, y, GUI_DISP_WIDTH - 1, y + height - 1);
			disp.PutPixel(0, y, 0);
			disp.PutPixel(GUI_DISP_WIDTH - 1, y, 0);
			disp.PutPixel(GUI_DISP_WIDTH - 1, y + height - 1, 0);
			disp.PutPixel(0, y + height - 1, 0);
		}

		y += height;
		total_height += height;
	}
}
Exemple #3
0
void fc_step()
{
    //using fake data
#ifdef FAKE_ENABLE
    return;
#endif


    gps_step();

    bt_step();

    protocol_step();

    logger_step();

    wind_step();

    //logger always enabled
    if (config.autostart.flags & AUTOSTART_ALWAYS_ENABLED)
    {
        if (fc.vario.valid && fc.flight.state == FLIGHT_WAIT)
        {
            fc_takeoff();
        }
    }
    else
    {
        //auto start
        // baro valid, waiting to take off or landed, and enabled auto start
        if (fc.vario.valid && (fc.flight.state == FLIGHT_WAIT || fc.flight.state == FLIGHT_LAND) && config.autostart.start_sensititvity > 0)
        {
            if (abs(fc.altitude1 - fc.flight.autostart_altitude) > config.autostart.start_sensititvity)
            {
                fc_takeoff();
            }
            else
            {
                uint32_t t = task_get_ms_tick();

                if(t < fc.flight.autostart_timer)
                {
                    assert(0);
                    DEBUG("old %lu\n", fc.flight.autostart_timer);
                    DEBUG("act %lu\n", t);
                }

                //reset wait timer
                if (t - fc.flight.autostart_timer > (uint32_t)config.autostart.timeout * 1000ul)
                {
                    fc.flight.autostart_timer = t;
                    fc.flight.autostart_altitude = fc.altitude1;
                }
            }
        }

        //auto land
        // flying and auto land enabled
        if (fc.flight.state == FLIGHT_FLIGHT && config.autostart.land_sensititvity > 0)
        {
            if (abs(fc.altitude1 - fc.flight.autostart_altitude) < config.autostart.land_sensititvity)
            {
                uint32_t tick = task_get_ms_tick();

                if (tick < fc.flight.autostart_timer)
                {
                    assert(0);
                    DEBUG("TT %lu\n", tick);
                    DEBUG("AT %lu\n", fc.flight.autostart_timer);
                }
                else if (tick - fc.flight.autostart_timer > (uint32_t)config.autostart.timeout * 1000ul)
                {
                    //reduce timeout from flight time
                    fc.flight.timer += (uint32_t)config.autostart.timeout * 1000ul;

                    gui_reset_timeout();
                    fc_landing();
                }
            }
            else
            {
                fc.flight.autostart_altitude = fc.altitude1;
                fc.flight.autostart_timer = task_get_ms_tick();
            }
        }
    }


    //gps time sync
    if ((config.system.time_flags & TIME_SYNC) && fc.gps_data.fix_cnt == GPS_FIX_TIME_SYNC)
    {
        if (config.gui.menu_audio_flags & CFG_AUDIO_MENU_GPS)
            seq_start(&gps_ready, config.gui.alert_volume);

        fc_sync_gps_time();
        fc.gps_data.fix_cnt++;
    }

    //glide ratio
    //when you have GPS, baro and speed is higher than 2km/h and you are sinking <= -0.01
    if (fc.gps_data.valid && fc.vario.valid && fc.gps_data.groud_speed > FC_GLIDE_MIN_KNOTS && fc.vario.avg <= FC_GLIDE_MIN_SINK)
    {
        float spd_m = fc.gps_data.groud_speed * FC_KNOTS_TO_MPS;
        fc.glide_ratio = spd_m / abs(fc.vario.avg);

        fc.glide_ratio_valid = true;
    }
    else
    {
        fc.glide_ratio_valid = false;
    }

    //flight logger
    if (config.logger.enabled)
    {
        if (fc.flight.state == FLIGHT_FLIGHT && !logger_active() && time_is_set() && !logger_error())
        {
            logger_start();
        }
    }

    //flight statistic
    if (fc.flight.state == FLIGHT_FLIGHT)
    {
        int16_t t_vario = fc.vario.avg * 100;

        if (fc.altitude1 > fc.flight.stats.max_alt)
            fc.flight.stats.max_alt = fc.altitude1;
        if (fc.altitude1 < fc.flight.stats.min_alt)
            fc.flight.stats.min_alt = fc.altitude1;

        if (t_vario > fc.flight.stats.max_climb)
            fc.flight.stats.max_climb = t_vario;
        if (t_vario < fc.flight.stats.max_sink)
            fc.flight.stats.max_sink = t_vario;
    }
}