sadmen
/
openpilot_comma
mirror of https://github.com/commaai/openpilot.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

UI: move c-capnp to c++ (#1455)

Browse Source 
* ui:move c-capnp to c++

* move Subsockets into vector

* rename reader to msg

include cereal/gen/cpp/log.capnp

* fix some errors

restore some changes

restore previous

* cleanup codes

cleanup codes

* remove unused variable alert_size

* handle capnproto's enum in a robust way

add break to default

* switch -> std:map

* use static std::map instead of switch

do cleanup

* fix wrong variable name

* use FlatArrayMessageReader instead of custom MessageReader

remove messagehelp.h

Revert "use FlatArrayMessageReader instead of custom MessageReader"

This reverts commit 57d8b6b1e2b4bad908246f35eb068535b1627167.

use FlatArrayMessageReader instead of custom MessageReader

add header file

remove capnp_c lib,add kj lib

include serialize.h

fix

remove duplicate includes
old-commit-hash: ee725534bb
commatwo_master
Dean Lee 5 years ago committed by GitHub
parent 8450ae3541
commit 90af65c41c
7 changed files with 225 additions and 322 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      selfdrive/ui/SConscript
  2. 36
      selfdrive/ui/paint.cc
  3. 58
      selfdrive/ui/sidebar.cc
  4. 22
      selfdrive/ui/sound.cc
  5. 4
      selfdrive/ui/sound.hpp
  6. 392
      selfdrive/ui/ui.cc
  7. 33
      selfdrive/ui/ui.hpp

2
selfdrive/ui/SConscript
Unescape View File

@ -1,7 +1,7 @@
Import('env', 'arch', 'common', 'messaging', 'gpucommon', 'visionipc', 'cereal') Import('env', 'arch', 'common', 'messaging', 'gpucommon', 'visionipc', 'cereal')
src = ['ui.cc', 'paint.cc', 'sidebar.cc', '#phonelibs/nanovg/nanovg.c'] src = ['ui.cc', 'paint.cc', 'sidebar.cc', '#phonelibs/nanovg/nanovg.c']
libs = [common, 'zmq', 'czmq', 'capnp', 'capnp_c', 'm', cereal, messaging, gpucommon, visionipc] libs = [common, 'zmq', 'czmq', 'capnp', 'kj', 'm', cereal, messaging, gpucommon, visionipc]
if arch == "aarch64": if arch == "aarch64":
src += ['sound.cc', 'slplay.c'] src += ['sound.cc', 'slplay.c']

36
selfdrive/ui/paint.cc
Unescape View File

@ -1,6 +1,6 @@
#include <assert.h>
#include "ui.hpp" #include "ui.hpp"
#include <assert.h>
#include <map>
#include "common/util.h" #include "common/util.h"
#define NANOVG_GLES3_IMPLEMENTATION #define NANOVG_GLES3_IMPLEMENTATION
@ -27,13 +27,6 @@ const uint8_t alert_colors[][4] = {
[STATUS_ALERT] = {0xC9, 0x22, 0x31, 0xf1}, [STATUS_ALERT] = {0xC9, 0x22, 0x31, 0xf1},
}; };
const int alert_sizes[] = {
[ALERTSIZE_NONE] = 0,
[ALERTSIZE_SMALL] = 241,
[ALERTSIZE_MID] = 390,
[ALERTSIZE_FULL] = vwp_h,
};
// Projects a point in car to space to the corresponding point in full frame // Projects a point in car to space to the corresponding point in full frame
// image space. // image space.
vec3 car_space_to_full_frame(const UIState *s, vec4 car_space_projective) { vec3 car_space_to_full_frame(const UIState *s, vec4 car_space_projective) {
@ -670,18 +663,25 @@ static void ui_draw_vision_footer(UIState *s) {
#endif #endif
} }
void ui_draw_vision_alert(UIState *s, int va_size, int va_color, void ui_draw_vision_alert(UIState *s, cereal::ControlsState::AlertSize va_size, int va_color,
const char* va_text1, const char* va_text2) { const char* va_text1, const char* va_text2) {
static std::map<cereal::ControlsState::AlertSize, const int> alert_size_map = {
{cereal::ControlsState::AlertSize::NONE, 0},
{cereal::ControlsState::AlertSize::SMALL, 241},
{cereal::ControlsState::AlertSize::MID, 390},
{cereal::ControlsState::AlertSize::FULL, vwp_h}};
const UIScene *scene = &s->scene; const UIScene *scene = &s->scene;
const bool hasSidebar = !scene->uilayout_sidebarcollapsed; const bool hasSidebar = !scene->uilayout_sidebarcollapsed;
const bool mapEnabled = scene->uilayout_mapenabled; const bool mapEnabled = scene->uilayout_mapenabled;
bool longAlert1 = strlen(va_text1) > 15; bool longAlert1 = strlen(va_text1) > 15;
const uint8_t *color = alert_colors[va_color]; const uint8_t *color = alert_colors[va_color];
const int alr_s = alert_sizes[va_size]; int alr_s = alert_size_map[va_size];
const int alr_x = scene->ui_viz_rx-(mapEnabled?(hasSidebar?nav_w:(nav_ww)):0)-bdr_s; const int alr_x = scene->ui_viz_rx-(mapEnabled?(hasSidebar?nav_w:(nav_ww)):0)-bdr_s;
const int alr_w = scene->ui_viz_rw+(mapEnabled?(hasSidebar?nav_w:(nav_ww)):0)+(bdr_s*2); const int alr_w = scene->ui_viz_rw+(mapEnabled?(hasSidebar?nav_w:(nav_ww)):0)+(bdr_s*2);
const int alr_h = alr_s+(va_size==ALERTSIZE_NONE?0:bdr_s); const int alr_h = alr_s+(va_size==cereal::ControlsState::AlertSize::NONE?0:bdr_s);
const int alr_y = vwp_h-alr_h; const int alr_y = vwp_h-alr_h;
ui_draw_rect(s->vg, alr_x, alr_y, alr_w, alr_h, nvgRGBA(color[0],color[1],color[2],(color[3]*s->alert_blinking_alpha))); ui_draw_rect(s->vg, alr_x, alr_y, alr_w, alr_h, nvgRGBA(color[0],color[1],color[2],(color[3]*s->alert_blinking_alpha)));
@ -693,12 +693,12 @@ void ui_draw_vision_alert(UIState *s, int va_size, int va_color,
nvgFillColor(s->vg, COLOR_WHITE); nvgFillColor(s->vg, COLOR_WHITE);
nvgTextAlign(s->vg, NVG_ALIGN_CENTER | NVG_ALIGN_BASELINE); nvgTextAlign(s->vg, NVG_ALIGN_CENTER | NVG_ALIGN_BASELINE);
if (va_size == ALERTSIZE_SMALL) { if (va_size == cereal::ControlsState::AlertSize::SMALL) {
ui_draw_text(s->vg, alr_x+alr_w/2, alr_y+alr_h/2+15, va_text1, 40*2.5, COLOR_WHITE, s->font_sans_semibold); ui_draw_text(s->vg, alr_x+alr_w/2, alr_y+alr_h/2+15, va_text1, 40*2.5, COLOR_WHITE, s->font_sans_semibold);
} else if (va_size== ALERTSIZE_MID) { } else if (va_size == cereal::ControlsState::AlertSize::MID) {
ui_draw_text(s->vg, alr_x+alr_w/2, alr_y+alr_h/2-45, va_text1, 48*2.5, COLOR_WHITE, s->font_sans_bold); ui_draw_text(s->vg, alr_x+alr_w/2, alr_y+alr_h/2-45, va_text1, 48*2.5, COLOR_WHITE, s->font_sans_bold);
ui_draw_text(s->vg, alr_x+alr_w/2, alr_y+alr_h/2+75, va_text2, 36*2.5, COLOR_WHITE, s->font_sans_regular); ui_draw_text(s->vg, alr_x+alr_w/2, alr_y+alr_h/2+75, va_text2, 36*2.5, COLOR_WHITE, s->font_sans_regular);
} else if (va_size== ALERTSIZE_FULL) { } else if (va_size == cereal::ControlsState::AlertSize::FULL) {
nvgFontSize(s->vg, (longAlert1?72:96)*2.5); nvgFontSize(s->vg, (longAlert1?72:96)*2.5);
nvgFontFaceId(s->vg, s->font_sans_bold); nvgFontFaceId(s->vg, s->font_sans_bold);
nvgTextAlign(s->vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE); nvgTextAlign(s->vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
@ -734,10 +734,10 @@ static void ui_draw_vision(UIState *s) {
ui_draw_driver_view(s); ui_draw_driver_view(s);
} }
if (scene->alert_size != ALERTSIZE_NONE) { if (scene->alert_size != cereal::ControlsState::AlertSize::NONE) {
// Controls Alerts // Controls Alerts
ui_draw_vision_alert(s, scene->alert_size, s->status, ui_draw_vision_alert(s, scene->alert_size, s->status,
scene->alert_text1, scene->alert_text2); scene->alert_text1.c_str(), scene->alert_text2.c_str());
} else { } else {
if (!scene->frontview){ui_draw_vision_footer(s);} if (!scene->frontview){ui_draw_vision_footer(s);}
} }
@ -759,7 +759,7 @@ void ui_draw(UIState *s) {
glViewport(0, 0, s->fb_w, s->fb_h); glViewport(0, 0, s->fb_w, s->fb_h);
nvgBeginFrame(s->vg, s->fb_w, s->fb_h, 1.0f); nvgBeginFrame(s->vg, s->fb_w, s->fb_h, 1.0f);
ui_draw_sidebar(s); ui_draw_sidebar(s);
if (s->started && s->active_app == cereal_UiLayoutState_App_none && s->status != STATUS_STOPPED && s->vision_seen) { if (s->started && s->active_app == cereal::UiLayoutState::App::NONE && s->status != STATUS_STOPPED && s->vision_seen) {
ui_draw_vision(s); ui_draw_vision(s);
} }
nvgEndFrame(s->vg); nvgEndFrame(s->vg);

58
selfdrive/ui/sidebar.cc
Unescape View File

@ -1,6 +1,7 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <math.h> #include <math.h>
#include <map>
#include "ui.hpp" #include "ui.hpp"
static void ui_draw_sidebar_background(UIState *s) { static void ui_draw_sidebar_background(UIState *s) {
@ -9,28 +10,32 @@ static void ui_draw_sidebar_background(UIState *s) {
} }
static void ui_draw_sidebar_settings_button(UIState *s) { static void ui_draw_sidebar_settings_button(UIState *s) {
bool settingsActive = s->active_app == cereal_UiLayoutState_App_settings; bool settingsActive = s->active_app == cereal::UiLayoutState::App::SETTINGS;
const int settings_btn_xr = !s->scene.uilayout_sidebarcollapsed ? settings_btn_x : -(sbr_w); const int settings_btn_xr = !s->scene.uilayout_sidebarcollapsed ? settings_btn_x : -(sbr_w);
ui_draw_image(s->vg, settings_btn_xr, settings_btn_y, settings_btn_w, settings_btn_h, s->img_button_settings, settingsActive ? 1.0f : 0.65f); ui_draw_image(s->vg, settings_btn_xr, settings_btn_y, settings_btn_w, settings_btn_h, s->img_button_settings, settingsActive ? 1.0f : 0.65f);
} }
static void ui_draw_sidebar_home_button(UIState *s) { static void ui_draw_sidebar_home_button(UIState *s) {
bool homeActive = s->active_app == cereal_UiLayoutState_App_home; bool homeActive = s->active_app == cereal::UiLayoutState::App::HOME;
const int home_btn_xr = !s->scene.uilayout_sidebarcollapsed ? home_btn_x : -(sbr_w); const int home_btn_xr = !s->scene.uilayout_sidebarcollapsed ? home_btn_x : -(sbr_w);
ui_draw_image(s->vg, home_btn_xr, home_btn_y, home_btn_w, home_btn_h, s->img_button_home, homeActive ? 1.0f : 0.65f); ui_draw_image(s->vg, home_btn_xr, home_btn_y, home_btn_w, home_btn_h, s->img_button_home, homeActive ? 1.0f : 0.65f);
} }
static void ui_draw_sidebar_network_strength(UIState *s) { static void ui_draw_sidebar_network_strength(UIState *s) {
static std::map<cereal::ThermalData::NetworkStrength, int> network_strength_map = {
{cereal::ThermalData::NetworkStrength::UNKNOWN, 1},
{cereal::ThermalData::NetworkStrength::POOR, 2},
{cereal::ThermalData::NetworkStrength::MODERATE, 3},
{cereal::ThermalData::NetworkStrength::GOOD, 4},
{cereal::ThermalData::NetworkStrength::GREAT, 5}};
const int network_img_h = 27; const int network_img_h = 27;
const int network_img_w = 176; const int network_img_w = 176;
const int network_img_x = !s->scene.uilayout_sidebarcollapsed ? 58 : -(sbr_w); const int network_img_x = !s->scene.uilayout_sidebarcollapsed ? 58 : -(sbr_w);
const int network_img_y = 196; const int network_img_y = 196;
const int network_img = s->scene.networkType == cereal_ThermalData_NetworkType_none ? const int img_idx = s->scene.networkType == cereal::ThermalData::NetworkType::NONE ? 0 : network_strength_map[s->scene.networkStrength];
s->img_network[0] : s->img_network[s->scene.networkStrength + 1]; ui_draw_image(s->vg, network_img_x, network_img_y, network_img_w, network_img_h, s->img_network[img_idx], 1.0f);
ui_draw_image(s->vg, network_img_x, network_img_y, network_img_w, network_img_h, network_img, 1.0f);
} }
static void ui_draw_sidebar_battery_icon(UIState *s) { static void ui_draw_sidebar_battery_icon(UIState *s) {
@ -39,8 +44,7 @@ static void ui_draw_sidebar_battery_icon(UIState *s) {
const int battery_img_x = !s->scene.uilayout_sidebarcollapsed ? 160 : -(sbr_w); const int battery_img_x = !s->scene.uilayout_sidebarcollapsed ? 160 : -(sbr_w);
const int battery_img_y = 255; const int battery_img_y = 255;
int battery_img = strcmp(s->scene.batteryStatus, "Charging") == 0 ? int battery_img = s->scene.batteryCharging ? s->img_battery_charging : s->img_battery;
s->img_battery_charging : s->img_battery;
ui_draw_rect(s->vg, battery_img_x + 6, battery_img_y + 5, ui_draw_rect(s->vg, battery_img_x + 6, battery_img_y + 5,
((battery_img_w - 19) * (s->scene.batteryPercent * 0.01)), battery_img_h - 11, COLOR_WHITE); ((battery_img_w - 19) * (s->scene.batteryPercent * 0.01)), battery_img_h - 11, COLOR_WHITE);
@ -49,22 +53,23 @@ static void ui_draw_sidebar_battery_icon(UIState *s) {
} }
static void ui_draw_sidebar_network_type(UIState *s) { static void ui_draw_sidebar_network_type(UIState *s) {
static std::map<cereal::ThermalData::NetworkType, const char *> network_type_map = {
{cereal::ThermalData::NetworkType::NONE, "--"},
{cereal::ThermalData::NetworkType::WIFI, "WiFi"},
{cereal::ThermalData::NetworkType::CELL2_G, "2G"},
{cereal::ThermalData::NetworkType::CELL3_G, "3G"},
{cereal::ThermalData::NetworkType::CELL4_G, "4G"},
{cereal::ThermalData::NetworkType::CELL5_G, "5G"}};
const int network_x = !s->scene.uilayout_sidebarcollapsed ? 50 : -(sbr_w); const int network_x = !s->scene.uilayout_sidebarcollapsed ? 50 : -(sbr_w);
const int network_y = 273; const int network_y = 273;
const int network_w = 100; const int network_w = 100;
const int network_h = 100; const int network_h = 100;
const char *network_types[6] = {"--", "WiFi", "2G", "3G", "4G", "5G"}; const char *network_type = network_type_map[s->scene.networkType];
char network_type_str[32];
if (s->scene.networkType <= 5) {
snprintf(network_type_str, sizeof(network_type_str), "%s", network_types[s->scene.networkType]);
}
nvgFillColor(s->vg, COLOR_WHITE); nvgFillColor(s->vg, COLOR_WHITE);
nvgFontSize(s->vg, 48); nvgFontSize(s->vg, 48);
nvgFontFaceId(s->vg, s->font_sans_regular); nvgFontFaceId(s->vg, s->font_sans_regular);
nvgTextAlign(s->vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE); nvgTextAlign(s->vg, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
nvgTextBox(s->vg, network_x, network_y, network_w, network_type_str, NULL); nvgTextBox(s->vg, network_x, network_y, network_w, network_type ? network_type : "--", NULL);
} }
static void ui_draw_sidebar_metric(UIState *s, const char* label_str, const char* value_str, const int severity, const int y_offset, const char* message_str) { static void ui_draw_sidebar_metric(UIState *s, const char* label_str, const char* value_str, const int severity, const int y_offset, const char* message_str) {
@ -113,28 +118,21 @@ static void ui_draw_sidebar_metric(UIState *s, const char* label_str, const char
} }
static void ui_draw_sidebar_temp_metric(UIState *s) { static void ui_draw_sidebar_temp_metric(UIState *s) {
int temp_severity; static std::map<cereal::ThermalData::ThermalStatus, const int> temp_severity_map = {
{cereal::ThermalData::ThermalStatus::GREEN, 0},
{cereal::ThermalData::ThermalStatus::YELLOW, 1},
{cereal::ThermalData::ThermalStatus::RED, 2},
{cereal::ThermalData::ThermalStatus::DANGER, 3}};
char temp_label_str[32]; char temp_label_str[32];
char temp_value_str[32]; char temp_value_str[32];
char temp_value_unit[32]; char temp_value_unit[32];
const int temp_y_offset = 0; const int temp_y_offset = 0;
if (s->scene.thermalStatus == cereal_ThermalData_ThermalStatus_green) {
temp_severity = 0;
} else if (s->scene.thermalStatus == cereal_ThermalData_ThermalStatus_yellow) {
temp_severity = 1;
} else if (s->scene.thermalStatus == cereal_ThermalData_ThermalStatus_red) {
temp_severity = 2;
} else if (s->scene.thermalStatus == cereal_ThermalData_ThermalStatus_danger) {
temp_severity = 3;
}
snprintf(temp_value_str, sizeof(temp_value_str), "%d", s->scene.paTemp); snprintf(temp_value_str, sizeof(temp_value_str), "%d", s->scene.paTemp);
snprintf(temp_value_unit, sizeof(temp_value_unit), "%s", "°C"); snprintf(temp_value_unit, sizeof(temp_value_unit), "%s", "°C");
snprintf(temp_label_str, sizeof(temp_label_str), "%s", "TEMP"); snprintf(temp_label_str, sizeof(temp_label_str), "%s", "TEMP");
strcat(temp_value_str, temp_value_unit); strcat(temp_value_str, temp_value_unit);
ui_draw_sidebar_metric(s, temp_label_str, temp_value_str, temp_severity, temp_y_offset, NULL); ui_draw_sidebar_metric(s, temp_label_str, temp_value_str, temp_severity_map[s->scene.thermalStatus], temp_y_offset, NULL);
} }
static void ui_draw_sidebar_panda_metric(UIState *s) { static void ui_draw_sidebar_panda_metric(UIState *s) {
@ -142,7 +140,7 @@ static void ui_draw_sidebar_panda_metric(UIState *s) {
char panda_message_str[32]; char panda_message_str[32];
const int panda_y_offset = 32 + 148; const int panda_y_offset = 32 + 148;
if (s->scene.hwType == cereal_HealthData_HwType_unknown) { if (s->scene.hwType == cereal::HealthData::HwType::UNKNOWN) {
panda_severity = 2; panda_severity = 2;
snprintf(panda_message_str, sizeof(panda_message_str), "%s", "NO\nVEHICLE"); snprintf(panda_message_str, sizeof(panda_message_str), "%s", "NO\nVEHICLE");
} else { } else {

22
selfdrive/ui/sound.cc
Unescape View File

@ -28,19 +28,19 @@ void set_volume(int volume) {
sound_file sound_table[] = { sound_file sound_table[] = {
{ cereal_CarControl_HUDControl_AudibleAlert_chimeDisengage, "../assets/sounds/disengaged.wav", false }, { cereal::CarControl::HUDControl::AudibleAlert::CHIME_DISENGAGE, "../assets/sounds/disengaged.wav", false },
{ cereal_CarControl_HUDControl_AudibleAlert_chimeEngage, "../assets/sounds/engaged.wav", false }, { cereal::CarControl::HUDControl::AudibleAlert::CHIME_ENGAGE, "../assets/sounds/engaged.wav", false },
{ cereal_CarControl_HUDControl_AudibleAlert_chimeWarning1, "../assets/sounds/warning_1.wav", false }, { cereal::CarControl::HUDControl::AudibleAlert::CHIME_WARNING1, "../assets/sounds/warning_1.wav", false },
{ cereal_CarControl_HUDControl_AudibleAlert_chimeWarning2, "../assets/sounds/warning_2.wav", false }, { cereal::CarControl::HUDControl::AudibleAlert::CHIME_WARNING2, "../assets/sounds/warning_2.wav", false },
{ cereal_CarControl_HUDControl_AudibleAlert_chimeWarning2Repeat, "../assets/sounds/warning_2.wav", true }, { cereal::CarControl::HUDControl::AudibleAlert::CHIME_WARNING2_REPEAT, "../assets/sounds/warning_2.wav", true },
{ cereal_CarControl_HUDControl_AudibleAlert_chimeWarningRepeat, "../assets/sounds/warning_repeat.wav", true }, { cereal::CarControl::HUDControl::AudibleAlert::CHIME_WARNING_REPEAT, "../assets/sounds/warning_repeat.wav", true },
{ cereal_CarControl_HUDControl_AudibleAlert_chimeError, "../assets/sounds/error.wav", false }, { cereal::CarControl::HUDControl::AudibleAlert::CHIME_ERROR, "../assets/sounds/error.wav", false },
{ cereal_CarControl_HUDControl_AudibleAlert_chimePrompt, "../assets/sounds/error.wav", false }, { cereal::CarControl::HUDControl::AudibleAlert::CHIME_PROMPT, "../assets/sounds/error.wav", false },
{ cereal_CarControl_HUDControl_AudibleAlert_none, NULL, false }, { cereal::CarControl::HUDControl::AudibleAlert::NONE, NULL, false },
}; };
sound_file* get_sound_file(AudibleAlert alert) { sound_file* get_sound_file(AudibleAlert alert) {
for (sound_file *s = sound_table; s->alert != cereal_CarControl_HUDControl_AudibleAlert_none; s++) { for (sound_file *s = sound_table; s->alert != cereal::CarControl::HUDControl::AudibleAlert::NONE; s++) {
if (s->alert == alert) { if (s->alert == alert) {
return s; return s;
} }
@ -74,7 +74,7 @@ void ui_sound_init() {
slplay_setup(&error); slplay_setup(&error);
if (error) goto fail; if (error) goto fail;
for (sound_file *s = sound_table; s->alert != cereal_CarControl_HUDControl_AudibleAlert_none; s++) { for (sound_file *s = sound_table; s->alert != cereal::CarControl::HUDControl::AudibleAlert::NONE; s++) {
slplay_create_player_for_uri(s->uri, &error); slplay_create_player_for_uri(s->uri, &error);
if (error) goto fail; if (error) goto fail;
} }

4
selfdrive/ui/sound.hpp
Unescape View File

@ -1,9 +1,9 @@
#ifndef __SOUND_HPP #ifndef __SOUND_HPP
#define __SOUND_HPP #define __SOUND_HPP
#include "cereal/gen/c/log.capnp.h" #include "cereal/gen/cpp/log.capnp.h"
typedef enum cereal_CarControl_HUDControl_AudibleAlert AudibleAlert; typedef cereal::CarControl::HUDControl::AudibleAlert AudibleAlert;
void ui_sound_init(); void ui_sound_init();
void ui_sound_destroy(); void ui_sound_destroy();

392
selfdrive/ui/ui.cc
Unescape View File

@ -1,3 +1,4 @@
#include "ui.hpp"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdbool.h> #include <stdbool.h>
@ -5,9 +6,8 @@
#include <assert.h> #include <assert.h>
#include <sys/mman.h> #include <sys/mman.h>
#include <sys/resource.h> #include <sys/resource.h>
#include <capnp/serialize.h>
#include <czmq.h> #include <czmq.h>
#include "common/util.h" #include "common/util.h"
#include "common/timing.h" #include "common/timing.h"
#include "common/swaglog.h" #include "common/swaglog.h"
@ -15,9 +15,6 @@
#include "common/visionimg.h" #include "common/visionimg.h"
#include "common/params.h" #include "common/params.h"
#include "ui.hpp"
#include "sound.hpp"
static int last_brightness = -1; static int last_brightness = -1;
static void set_brightness(UIState *s, int brightness) { static void set_brightness(UIState *s, int brightness) {
if (last_brightness != brightness && (s->awake || brightness == 0)) { if (last_brightness != brightness && (s->awake || brightness == 0)) {
@ -69,35 +66,21 @@ static void set_awake(UIState *s, bool awake) {
} }
static void update_offroad_layout_state(UIState *s) { static void update_offroad_layout_state(UIState *s) {
struct capn rc; capnp::MallocMessageBuilder msg;
capn_init_malloc(&rc); auto event = msg.initRoot<cereal::Event>();
struct capn_segment *cs = capn_root(&rc).seg; event.setLogMonoTime(nanos_since_boot());
auto layout = event.initUiLayoutState();
cereal_UiLayoutState_ptr layoutp = cereal_new_UiLayoutState(cs); layout.setActiveApp(s->active_app);
struct cereal_UiLayoutState layoutd = { layout.setSidebarCollapsed(s->scene.uilayout_sidebarcollapsed);
.activeApp = (cereal_UiLayoutState_App)s->active_app, auto words = capnp::messageToFlatArray(msg);
.sidebarCollapsed = s->scene.uilayout_sidebarcollapsed, auto bytes = words.asBytes();
}; s->offroad_sock->send((char*)bytes.begin(), bytes.size());
cereal_write_UiLayoutState(&layoutd, layoutp); LOGD("setting active app to %d with sidebar %d", (int)s->active_app, s->scene.uilayout_sidebarcollapsed);
LOGD("setting active app to %d with sidebar %d", layoutd.activeApp, layoutd.sidebarCollapsed);
cereal_Event_ptr eventp = cereal_new_Event(cs);
struct cereal_Event event = {
.logMonoTime = nanos_since_boot(),
.which = cereal_Event_uiLayoutState,
.uiLayoutState = layoutp,
};
cereal_write_Event(&event, eventp);
capn_setp(capn_root(&rc), 0, eventp.p);
uint8_t buf[4096];
ssize_t rs = capn_write_mem(&rc, buf, sizeof(buf), 0);
s->offroad_sock->send((char*)buf, rs);
capn_free(&rc);
} }
static void navigate_to_settings(UIState *s) { static void navigate_to_settings(UIState *s) {
#ifdef QCOM #ifdef QCOM
s->active_app = cereal_UiLayoutState_App_settings; s->active_app = cereal::UiLayoutState::App::SETTINGS;
update_offroad_layout_state(s); update_offroad_layout_state(s);
#else #else
// computer UI doesn't have offroad settings // computer UI doesn't have offroad settings
@ -107,9 +90,9 @@ static void navigate_to_settings(UIState *s) {
static void navigate_to_home(UIState *s) { static void navigate_to_home(UIState *s) {
#ifdef QCOM #ifdef QCOM
if (s->started) { if (s->started) {
s->active_app = cereal_UiLayoutState_App_none; s->active_app = cereal::UiLayoutState::App::NONE;
} else { } else {
s->active_app = cereal_UiLayoutState_App_home; s->active_app = cereal::UiLayoutState::App::HOME;
} }
update_offroad_layout_state(s); update_offroad_layout_state(s);
#else #else
@ -140,7 +123,7 @@ static void handle_driver_view_touch(UIState *s, int touch_x, int touch_y) {
static void handle_vision_touch(UIState *s, int touch_x, int touch_y) { static void handle_vision_touch(UIState *s, int touch_x, int touch_y) {
if (s->started && (touch_x >= s->scene.ui_viz_rx - bdr_s) if (s->started && (touch_x >= s->scene.ui_viz_rx - bdr_s)
&& (s->active_app != cereal_UiLayoutState_App_settings)) { && (s->active_app != cereal::UiLayoutState::App::SETTINGS)) {
if (!s->scene.frontview) { if (!s->scene.frontview) {
s->scene.uilayout_sidebarcollapsed = !s->scene.uilayout_sidebarcollapsed; s->scene.uilayout_sidebarcollapsed = !s->scene.uilayout_sidebarcollapsed;
} else { } else {
@ -339,19 +322,15 @@ static void ui_init_vision(UIState *s, const VisionStreamBufs back_bufs,
s->limit_set_speed_timeout = UI_FREQ; s->limit_set_speed_timeout = UI_FREQ;
} }
static PathData read_path(cereal_ModelData_PathData_ptr pathp) { static PathData read_path(cereal::ModelData::PathData::Reader pathp) {
PathData ret = {0}; PathData ret = {0};
struct cereal_ModelData_PathData pathd; ret.prob = pathp.getProb();
cereal_read_ModelData_PathData(&pathd, pathp); ret.std = pathp.getStd();
ret.prob = pathd.prob;
ret.std = pathd.std;
capn_list32 polyp = pathd.poly; auto polyp = pathp.getPoly();
capn_resolve(&polyp.p);
for (int i = 0; i < POLYFIT_DEGREE; i++) { for (int i = 0; i < POLYFIT_DEGREE; i++) {
ret.poly[i] = capn_to_f32(capn_get32(polyp, i)); ret.poly[i] = polyp[i];
} }
// Compute points locations // Compute points locations
@ -362,20 +341,16 @@ static PathData read_path(cereal_ModelData_PathData_ptr pathp) {
return ret; return ret;
} }
static ModelData read_model(cereal_ModelData_ptr modelp) { static ModelData read_model(cereal::ModelData::Reader model) {
struct cereal_ModelData modeld;
cereal_read_ModelData(&modeld, modelp);
ModelData d = {0}; ModelData d = {0};
d.path = read_path(modeld.path); d.path = read_path(model.getPath());
d.left_lane = read_path(modeld.leftLane); d.left_lane = read_path(model.getLeftLane());
d.right_lane = read_path(modeld.rightLane); d.right_lane = read_path(model.getRightLane());
struct cereal_ModelData_LeadData leadd; auto leadd = model.getLead();
cereal_read_ModelData_LeadData(&leadd, modeld.lead);
d.lead = (LeadData){ d.lead = (LeadData){
.dist = leadd.dist, .prob = leadd.prob, .std = leadd.std, .dist = leadd.getDist(), .prob = leadd.getProb(), .std = leadd.getStd(),
}; };
return d; return d;
@ -387,207 +362,150 @@ static void update_status(UIState *s, int status) {
} }
} }
void handle_message(UIState *s, Message* msg) {
void handle_message(UIState *s, Message * msg) { auto amsg = kj::heapArray<capnp::word>((msg->getSize() / sizeof(capnp::word)) + 1);
struct capn ctx; memcpy(amsg.begin(), msg->getData(), msg->getSize());
capn_init_mem(&ctx, (uint8_t*)msg->getData(), msg->getSize(), 0); capnp::FlatArrayMessageReader cmsg(amsg);
cereal::Event::Reader event = cmsg.getRoot<cereal::Event>();
cereal_Event_ptr eventp;
eventp.p = capn_getp(capn_root(&ctx), 0, 1); auto which = event.which();
struct cereal_Event eventd; UIScene &scene = s->scene;
cereal_read_Event(&eventd, eventp); if (which == cereal::Event::CONTROLS_STATE && s->started) {
auto data = event.getControlsState();
if (eventd.which == cereal_Event_controlsState && s->started) {
struct cereal_ControlsState datad;
cereal_read_ControlsState(&datad, eventd.controlsState);
s->controls_timeout = 1 * UI_FREQ; s->controls_timeout = 1 * UI_FREQ;
s->scene.frontview = datad.rearViewCam; scene.frontview = data.getRearViewCam();
if (!s->scene.frontview){s->controls_seen = true;} if (!scene.frontview){ s->controls_seen = true; }
if (datad.vCruise != s->scene.v_cruise) { if (data.getVCruise() != scene.v_cruise) {
s->scene.v_cruise_update_ts = eventd.logMonoTime; scene.v_cruise_update_ts = event.getLogMonoTime();
} }
s->scene.v_cruise = datad.vCruise; scene.v_cruise = data.getVCruise();
s->scene.v_ego = datad.vEgo; scene.v_ego = data.getVEgo();
s->scene.curvature = datad.curvature; scene.curvature = data.getCurvature();
s->scene.engaged = datad.enabled; scene.engaged = data.getEnabled();
s->scene.engageable = datad.engageable; scene.engageable = data.getEngageable();
s->scene.gps_planner_active = datad.gpsPlannerActive; scene.gps_planner_active = data.getGpsPlannerActive();
s->scene.monitoring_active = datad.driverMonitoringOn; scene.monitoring_active = data.getDriverMonitoringOn();
s->scene.decel_for_model = datad.decelForModel; scene.decel_for_model = data.getDecelForModel();
auto alert_sound = data.getAlertSound();
if (datad.alertSound != cereal_CarControl_HUDControl_AudibleAlert_none && datad.alertSound != s->alert_sound) { const auto sound_none = cereal::CarControl::HUDControl::AudibleAlert::NONE;
if (s->alert_sound != cereal_CarControl_HUDControl_AudibleAlert_none) { if (alert_sound != s->alert_sound){
if (s->alert_sound != sound_none){
stop_alert_sound(s->alert_sound); stop_alert_sound(s->alert_sound);
} }
play_alert_sound(datad.alertSound); if (alert_sound != sound_none){
play_alert_sound(alert_sound);
s->alert_sound = datad.alertSound; s->alert_type = data.getAlertType();
snprintf(s->alert_type, sizeof(s->alert_type), "%s", datad.alertType.str); }
} else if ((!datad.alertSound || datad.alertSound == cereal_CarControl_HUDControl_AudibleAlert_none) s->alert_sound = alert_sound;
&& s->alert_sound != cereal_CarControl_HUDControl_AudibleAlert_none) {
stop_alert_sound(s->alert_sound);
s->alert_type[0] = '\0';
s->alert_sound = cereal_CarControl_HUDControl_AudibleAlert_none;
}
if (datad.alertText1.str) {
snprintf(s->scene.alert_text1, sizeof(s->scene.alert_text1), "%s", datad.alertText1.str);
} else {
s->scene.alert_text1[0] = '\0';
}
if (datad.alertText2.str) {
snprintf(s->scene.alert_text2, sizeof(s->scene.alert_text2), "%s", datad.alertText2.str);
} else {
s->scene.alert_text2[0] = '\0';
}
s->scene.alert_ts = eventd.logMonoTime;
s->scene.alert_size = datad.alertSize;
if (datad.alertSize == cereal_ControlsState_AlertSize_none) {
s->alert_size = ALERTSIZE_NONE;
} else if (datad.alertSize == cereal_ControlsState_AlertSize_small) {
s->alert_size = ALERTSIZE_SMALL;
} else if (datad.alertSize == cereal_ControlsState_AlertSize_mid) {
s->alert_size = ALERTSIZE_MID;
} else if (datad.alertSize == cereal_ControlsState_AlertSize_full) {
s->alert_size = ALERTSIZE_FULL;
} }
scene.alert_text1 = data.getAlertText1();
if (datad.alertStatus == cereal_ControlsState_AlertStatus_userPrompt) { scene.alert_text2 = data.getAlertText2();
scene.alert_ts = event.getLogMonoTime();
scene.alert_size = data.getAlertSize();
auto alertStatus = data.getAlertStatus();
if (alertStatus == cereal::ControlsState::AlertStatus::USER_PROMPT) {
update_status(s, STATUS_WARNING); update_status(s, STATUS_WARNING);
} else if (datad.alertStatus == cereal_ControlsState_AlertStatus_critical) { } else if (alertStatus == cereal::ControlsState::AlertStatus::CRITICAL) {
update_status(s, STATUS_ALERT); update_status(s, STATUS_ALERT);
} else if (datad.enabled) { } else{
update_status(s, STATUS_ENGAGED); update_status(s, scene.engaged ? STATUS_ENGAGED : STATUS_DISENGAGED);
} else {
update_status(s, STATUS_DISENGAGED);
} }
s->scene.alert_blinkingrate = datad.alertBlinkingRate; scene.alert_blinkingrate = data.getAlertBlinkingRate();
if (datad.alertBlinkingRate > 0.) { if (scene.alert_blinkingrate > 0.) {
if (s->alert_blinked) { if (s->alert_blinked) {
if (s->alert_blinking_alpha > 0.0 && s->alert_blinking_alpha < 1.0) { if (s->alert_blinking_alpha > 0.0 && s->alert_blinking_alpha < 1.0) {
s->alert_blinking_alpha += (0.05*datad.alertBlinkingRate); s->alert_blinking_alpha += (0.05*scene.alert_blinkingrate);
} else { } else {
s->alert_blinked = false; s->alert_blinked = false;
} }
} else { } else {
if (s->alert_blinking_alpha > 0.25) { if (s->alert_blinking_alpha > 0.25) {
s->alert_blinking_alpha -= (0.05*datad.alertBlinkingRate); s->alert_blinking_alpha -= (0.05*scene.alert_blinkingrate);
} else { } else {
s->alert_blinking_alpha += 0.25; s->alert_blinking_alpha += 0.25;
s->alert_blinked = true; s->alert_blinked = true;
} }
} }
} }
} else if (eventd.which == cereal_Event_radarState) { } else if (which == cereal::Event::RADAR_STATE) {
struct cereal_RadarState datad; auto data = event.getRadarState();
cereal_read_RadarState(&datad, eventd.radarState);
struct cereal_RadarState_LeadData leaddatad; auto leaddatad = data.getLeadOne();
cereal_read_RadarState_LeadData(&leaddatad, datad.leadOne); scene.lead_status = leaddatad.getStatus();
s->scene.lead_status = leaddatad.status; scene.lead_d_rel = leaddatad.getDRel();
s->scene.lead_d_rel = leaddatad.dRel; scene.lead_y_rel = leaddatad.getYRel();
s->scene.lead_y_rel = leaddatad.yRel; scene.lead_v_rel = leaddatad.getVRel();
s->scene.lead_v_rel = leaddatad.vRel; auto leaddatad2 = data.getLeadTwo();
cereal_read_RadarState_LeadData(&leaddatad, datad.leadTwo); scene.lead_status2 = leaddatad2.getStatus();
s->scene.lead_status2 = leaddatad.status; scene.lead_d_rel2 = leaddatad2.getDRel();
s->scene.lead_d_rel2 = leaddatad.dRel; scene.lead_y_rel2 = leaddatad2.getYRel();
s->scene.lead_y_rel2 = leaddatad.yRel; scene.lead_v_rel2 = leaddatad2.getVRel();
s->scene.lead_v_rel2 = leaddatad.vRel;
s->livempc_or_radarstate_changed = true;
} else if (eventd.which == cereal_Event_liveCalibration) {
s->scene.world_objects_visible = true;
struct cereal_LiveCalibrationData datad;
cereal_read_LiveCalibrationData(&datad, eventd.liveCalibration);
capn_list32 extrinsicl = datad.extrinsicMatrix; s->livempc_or_radarstate_changed = true;
capn_resolve(&extrinsicl.p); // is this a bug? } else if (which == cereal::Event::LIVE_CALIBRATION) {
scene.world_objects_visible = true;
auto extrinsicl = event.getLiveCalibration().getExtrinsicMatrix();
for (int i = 0; i < 3 * 4; i++) { for (int i = 0; i < 3 * 4; i++) {
s->scene.extrinsic_matrix.v[i] = scene.extrinsic_matrix.v[i] = extrinsicl[i];
capn_to_f32(capn_get32(extrinsicl, i));
} }
} else if (eventd.which == cereal_Event_model) { } else if (which == cereal::Event::MODEL) {
s->scene.model = read_model(eventd.model); scene.model = read_model(event.getModel());
s->model_changed = true; s->model_changed = true;
} else if (eventd.which == cereal_Event_liveMpc) { } else if (which == cereal::Event::LIVE_MPC) {
struct cereal_LiveMpcData datad; auto data = event.getLiveMpc();
cereal_read_LiveMpcData(&datad, eventd.liveMpc);
capn_list32 x_list = datad.x;
capn_resolve(&x_list.p);
for (int i = 0; i < 50; i++){
s->scene.mpc_x[i] = capn_to_f32(capn_get32(x_list, i));
}
capn_list32 y_list = datad.y;
capn_resolve(&y_list.p);
auto x_list = data.getX();
auto y_list = data.getY();
for (int i = 0; i < 50; i++){ for (int i = 0; i < 50; i++){
s->scene.mpc_y[i] = capn_to_f32(capn_get32(y_list, i)); scene.mpc_x[i] = x_list[i];
scene.mpc_y[i] = y_list[i];
} }
s->livempc_or_radarstate_changed = true; s->livempc_or_radarstate_changed = true;
} else if (eventd.which == cereal_Event_uiLayoutState) { } else if (which == cereal::Event::UI_LAYOUT_STATE) {
struct cereal_UiLayoutState datad; auto data = event.getUiLayoutState();
cereal_read_UiLayoutState(&datad, eventd.uiLayoutState);
s->active_app = datad.activeApp; s->active_app = data.getActiveApp();
s->scene.uilayout_sidebarcollapsed = datad.sidebarCollapsed; scene.uilayout_sidebarcollapsed = data.getSidebarCollapsed();
if (datad.mockEngaged != s->scene.uilayout_mockengaged) { if (data.getMockEngaged() != scene.uilayout_mockengaged) {
s->scene.uilayout_mockengaged = datad.mockEngaged; scene.uilayout_mockengaged = data.getMockEngaged();
} }
} else if (eventd.which == cereal_Event_liveMapData) { } else if (which == cereal::Event::LIVE_MAP_DATA) {
struct cereal_LiveMapData datad; scene.map_valid = event.getLiveMapData().getMapValid();
cereal_read_LiveMapData(&datad, eventd.liveMapData); } else if (which == cereal::Event::THERMAL) {
s->scene.map_valid = datad.mapValid; auto data = event.getThermal();
} else if (eventd.which == cereal_Event_thermal) {
struct cereal_ThermalData datad; scene.networkType = data.getNetworkType();
cereal_read_ThermalData(&datad, eventd.thermal); scene.networkStrength = data.getNetworkStrength();
scene.batteryPercent = data.getBatteryPercent();
s->scene.networkType = datad.networkType; scene.batteryCharging = data.getBatteryStatus() == "Charging";
s->scene.networkStrength = datad.networkStrength; scene.freeSpace = data.getFreeSpace();
s->scene.batteryPercent = datad.batteryPercent; scene.thermalStatus = data.getThermalStatus();
snprintf(s->scene.batteryStatus, sizeof(s->scene.batteryStatus), "%s", datad.batteryStatus.str); scene.paTemp = data.getPa0();
s->scene.freeSpace = datad.freeSpace;
s->scene.thermalStatus = datad.thermalStatus; s->thermal_started = data.getStarted();
s->scene.paTemp = datad.pa0; } else if (which == cereal::Event::UBLOX_GNSS) {
auto data = event.getUbloxGnss();
s->thermal_started = datad.started; if (data.which() == cereal::UbloxGnss::MEASUREMENT_REPORT) {
scene.satelliteCount = data.getMeasurementReport().getNumMeas();
} else if (eventd.which == cereal_Event_ubloxGnss) {
struct cereal_UbloxGnss datad;
cereal_read_UbloxGnss(&datad, eventd.ubloxGnss);
if (datad.which == cereal_UbloxGnss_measurementReport) {
struct cereal_UbloxGnss_MeasurementReport reportdatad;
cereal_read_UbloxGnss_MeasurementReport(&reportdatad, datad.measurementReport);
s->scene.satelliteCount = reportdatad.numMeas;
} }
} else if (eventd.which == cereal_Event_health) { } else if (which == cereal::Event::HEALTH) {
struct cereal_HealthData datad; scene.hwType = event.getHealth().getHwType();
cereal_read_HealthData(&datad, eventd.health);
s->scene.hwType = datad.hwType;
s->hardware_timeout = 5*30; // 5 seconds at 30 fps s->hardware_timeout = 5*30; // 5 seconds at 30 fps
} else if (eventd.which == cereal_Event_driverState) { } else if (which == cereal::Event::DRIVER_STATE) {
struct cereal_DriverState datad; auto data = event.getDriverState();
cereal_read_DriverState(&datad, eventd.driverState); scene.face_prob = data.getFaceProb();
auto fxy_list = data.getFacePosition();
s->scene.face_prob = datad.faceProb; scene.face_x = fxy_list[0];
scene.face_y = fxy_list[1];
capn_list32 fxy_list = datad.facePosition; } else if (which == cereal::Event::D_MONITORING_STATE) {
capn_resolve(&fxy_list.p); auto data = event.getDMonitoringState();
s->scene.face_x = capn_to_f32(capn_get32(fxy_list, 0)); scene.is_rhd = data.getIsRHD();
s->scene.face_y = capn_to_f32(capn_get32(fxy_list, 1)); scene.awareness_status = data.getAwarenessStatus();
} else if (eventd.which == cereal_Event_dMonitoringState) { s->preview_started = data.getIsPreview();
struct cereal_DMonitoringState datad;
cereal_read_DMonitoringState(&datad, eventd.dMonitoringState);
s->scene.is_rhd = datad.isRHD;
s->scene.awareness_status = datad.awarenessStatus;
s->preview_started = datad.isPreview;
} }
s->started = s->thermal_started || s->preview_started ; s->started = s->thermal_started || s->preview_started ;
@ -598,17 +516,15 @@ void handle_message(UIState *s, Message * msg) {
s->alert_sound_timeout = 0; s->alert_sound_timeout = 0;
s->vision_seen = false; s->vision_seen = false;
s->controls_seen = false; s->controls_seen = false;
s->active_app = cereal_UiLayoutState_App_home; s->active_app = cereal::UiLayoutState::App::HOME;
update_offroad_layout_state(s); update_offroad_layout_state(s);
} }
} else if (s->status == STATUS_STOPPED) { } else if (s->status == STATUS_STOPPED) {
update_status(s, STATUS_DISENGAGED); update_status(s, STATUS_DISENGAGED);
s->active_app = cereal_UiLayoutState_App_none; s->active_app = cereal::UiLayoutState::App::NONE;
update_offroad_layout_state(s); update_offroad_layout_state(s);
} }
capn_free(&ctx);
} }
static void check_messages(UIState *s) { static void check_messages(UIState *s) {
@ -619,12 +535,11 @@ static void check_messages(UIState *s) {
break; break;
for (auto sock : polls){ for (auto sock : polls){
Message * msg = sock->receive(); Message *msg = sock->receive();
if (msg == NULL) continue; if (msg) {
handle_message(s, msg);
handle_message(s, msg); delete msg;
}
delete msg;
} }
} }
} }
@ -938,8 +853,6 @@ int is_leon() {
return strstr(str, "letv") != NULL; return strstr(str, "letv") != NULL;
} }
int main(int argc, char* argv[]) { int main(int argc, char* argv[]) {
int err; int err;
setpriority(PRIO_PROCESS, 0, -14); setpriority(PRIO_PROCESS, 0, -14);
@ -1054,7 +967,7 @@ int main(int argc, char* argv[]) {
if (s->hardware_timeout > 0) { if (s->hardware_timeout > 0) {
s->hardware_timeout--; s->hardware_timeout--;
} else { } else {
s->scene.hwType = cereal_HealthData_HwType_unknown; s->scene.hwType = cereal::HealthData::HwType::UNKNOWN;
} }
// Don't waste resources on drawing in case screen is off // Don't waste resources on drawing in case screen is off
@ -1076,17 +989,18 @@ int main(int argc, char* argv[]) {
if (s->controls_timeout > 0) { if (s->controls_timeout > 0) {
s->controls_timeout--; s->controls_timeout--;
} else { } else {
if (s->started && s->controls_seen && strcmp(s->scene.alert_text2, "Controls Unresponsive") != 0) { if (s->started && s->controls_seen && s->scene.alert_text2 != "Controls Unresponsive") {
LOGE("Controls unresponsive"); LOGE("Controls unresponsive");
s->scene.alert_size = ALERTSIZE_FULL; s->scene.alert_size = cereal::ControlsState::AlertSize::FULL;
update_status(s, STATUS_ALERT); update_status(s, STATUS_ALERT);
snprintf(s->scene.alert_text1, sizeof(s->scene.alert_text1), "%s", "TAKE CONTROL IMMEDIATELY"); s->scene.alert_text1 = "TAKE CONTROL IMMEDIATELY";
snprintf(s->scene.alert_text2, sizeof(s->scene.alert_text2), "%s", "Controls Unresponsive"); s->scene.alert_text2 = "Controls Unresponsive";
ui_draw_vision_alert(s, s->scene.alert_size, s->status, s->scene.alert_text1, s->scene.alert_text2);
ui_draw_vision_alert(s, s->scene.alert_size, s->status, s->scene.alert_text1.c_str(), s->scene.alert_text2.c_str());
s->alert_sound_timeout = 2 * UI_FREQ; s->alert_sound_timeout = 2 * UI_FREQ;
s->alert_sound = cereal_CarControl_HUDControl_AudibleAlert_chimeWarningRepeat; s->alert_sound = cereal::CarControl::HUDControl::AudibleAlert::CHIME_WARNING_REPEAT;
play_alert_sound(s->alert_sound); play_alert_sound(s->alert_sound);
} }
@ -1096,9 +1010,9 @@ int main(int argc, char* argv[]) {
// stop playing alert sound // stop playing alert sound
if ((!s->started || (s->started && s->alert_sound_timeout == 0)) && if ((!s->started || (s->started && s->alert_sound_timeout == 0)) &&
s->alert_sound != cereal_CarControl_HUDControl_AudibleAlert_none) { s->alert_sound != cereal::CarControl::HUDControl::AudibleAlert::NONE) {
stop_alert_sound(s->alert_sound); stop_alert_sound(s->alert_sound);
s->alert_sound = cereal_CarControl_HUDControl_AudibleAlert_none; s->alert_sound = cereal::CarControl::HUDControl::AudibleAlert::NONE;
} }
read_param_bool_timeout(&s->is_metric, "IsMetric", &s->is_metric_timeout); read_param_bool_timeout(&s->is_metric, "IsMetric", &s->is_metric_timeout);

33
selfdrive/ui/ui.hpp
Unescape View File

@ -1,6 +1,6 @@
#ifndef _UI_H #ifndef _UI_H
#define _UI_H #define _UI_H
#include "cereal/gen/cpp/log.capnp.h"
#ifdef __APPLE__ #ifdef __APPLE__
#include <OpenGL/gl3.h> #include <OpenGL/gl3.h>
#define NANOVG_GL3_IMPLEMENTATION #define NANOVG_GL3_IMPLEMENTATION
@ -14,7 +14,6 @@
#include <capnp/serialize.h> #include <capnp/serialize.h>
#include <pthread.h> #include <pthread.h>
#include "nanovg.h" #include "nanovg.h"
#include "common/mat.h" #include "common/mat.h"
@ -23,8 +22,6 @@
#include "common/framebuffer.h" #include "common/framebuffer.h"
#include "common/modeldata.h" #include "common/modeldata.h"
#include "messaging.hpp" #include "messaging.hpp"
#include "cereal/gen/c/log.capnp.h"
#include "sound.hpp" #include "sound.hpp"
#define STATUS_STOPPED 0 #define STATUS_STOPPED 0
@ -37,11 +34,6 @@
#define NET_DISCONNECTED 1 #define NET_DISCONNECTED 1
#define NET_ERROR 2 #define NET_ERROR 2
#define ALERTSIZE_NONE 0
#define ALERTSIZE_SMALL 1
#define ALERTSIZE_MID 2
#define ALERTSIZE_FULL 3
#define COLOR_BLACK nvgRGBA(0, 0, 0, 255) #define COLOR_BLACK nvgRGBA(0, 0, 0, 255)
#define COLOR_BLACK_ALPHA(x) nvgRGBA(0, 0, 0, x) #define COLOR_BLACK_ALPHA(x) nvgRGBA(0, 0, 0, x)
#define COLOR_WHITE nvgRGBA(255, 255, 255, 255) #define COLOR_WHITE nvgRGBA(255, 255, 255, 255)
@ -148,9 +140,9 @@ typedef struct UIScene {
int front_box_x, front_box_y, front_box_width, front_box_height; int front_box_x, front_box_y, front_box_width, front_box_height;
uint64_t alert_ts; uint64_t alert_ts;
char alert_text1[1024]; std::string alert_text1;
char alert_text2[1024]; std::string alert_text2;
uint8_t alert_size; cereal::ControlsState::AlertSize alert_size;
float alert_blinkingrate; float alert_blinkingrate;
float awareness_status; float awareness_status;
@ -158,14 +150,14 @@ typedef struct UIScene {
// Used to show gps planner status // Used to show gps planner status
bool gps_planner_active; bool gps_planner_active;
uint8_t networkType; cereal::ThermalData::NetworkType networkType;
uint8_t networkStrength; cereal::ThermalData::NetworkStrength networkStrength;
int batteryPercent; int batteryPercent;
char batteryStatus[64]; bool batteryCharging;
float freeSpace; float freeSpace;
uint8_t thermalStatus; cereal::ThermalData::ThermalStatus thermalStatus;
int paTemp; int paTemp;
int hwType; cereal::HealthData::HwType hwType;
int satelliteCount; int satelliteCount;
uint8_t athenaStatus; uint8_t athenaStatus;
} UIScene; } UIScene;
@ -227,7 +219,7 @@ typedef struct UIState {
Poller * poller; Poller * poller;
Poller * ublox_poller; Poller * ublox_poller;
int active_app; cereal::UiLayoutState::App active_app;
// vision state // vision state
bool vision_connected; bool vision_connected;
@ -282,9 +274,8 @@ typedef struct UIState {
bool limit_set_speed; bool limit_set_speed;
float speed_lim_off; float speed_lim_off;
bool is_ego_over_limit; bool is_ego_over_limit;
char alert_type[64]; std::string alert_type;
AudibleAlert alert_sound; AudibleAlert alert_sound;
int alert_size;
float alert_blinking_alpha; float alert_blinking_alpha;
bool alert_blinked; bool alert_blinked;
bool started; bool started;
@ -308,7 +299,7 @@ typedef struct UIState {
} UIState; } UIState;
// API // API
void ui_draw_vision_alert(UIState *s, int va_size, int va_color, void ui_draw_vision_alert(UIState *s, cereal::ControlsState::AlertSize va_size, int va_color,
const char* va_text1, const char* va_text2); const char* va_text1, const char* va_text2);
void ui_draw(UIState *s); void ui_draw(UIState *s);
void ui_draw_sidebar(UIState *s); void ui_draw_sidebar(UIState *s);

Write Preview
Loading…
Cancel
Save