781 lines
22 KiB
C
781 lines
22 KiB
C
/*
|
|
* Copyright (C) 2023 Daniele Lacamera <root@danielinux.net>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <stdint.h>
|
|
#include <stddef.h>
|
|
#include "ui.h"
|
|
#include "button.h"
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include "ksp-serial.h"
|
|
#include "led.h"
|
|
#include "adc.h"
|
|
#include <math.h>
|
|
#include "arm_math.h"
|
|
#include "ui.h"
|
|
#include "trig.h"
|
|
|
|
|
|
#define ROLL_CALIB (30)
|
|
#define PITCH_CALIB (0)
|
|
|
|
#define M_PI_INT 3
|
|
|
|
const char main_deck_name[] = "Main Deck";
|
|
static void main_deck_draw(void);
|
|
static void main_deck_run(uint32_t ev, void *arg);
|
|
|
|
static char _soi_target[20];
|
|
static int vdata_valid = 0;
|
|
|
|
static int show_pitch_roll_yaw = 0;
|
|
|
|
static char *soi_target(uint8_t SOI)
|
|
{
|
|
switch (SOI) {
|
|
case 100:
|
|
strcpy(_soi_target, "Kerbol");
|
|
break;
|
|
case 110:
|
|
strcpy(_soi_target, "Moho");
|
|
break;
|
|
case 120:
|
|
strcpy(_soi_target, "Eve");
|
|
break;
|
|
case 121:
|
|
strcpy(_soi_target, "Gilly");
|
|
break;
|
|
case 130:
|
|
strcpy(_soi_target, "Kerbin");
|
|
break;
|
|
case 131:
|
|
strcpy(_soi_target, "Mun");
|
|
break;
|
|
case 132:
|
|
strcpy(_soi_target, "Minmus");
|
|
break;
|
|
case 140:
|
|
strcpy(_soi_target, "Duna");
|
|
break;
|
|
case 141:
|
|
strcpy(_soi_target, "Ike");
|
|
break;
|
|
case 150:
|
|
strcpy(_soi_target, "Dres");
|
|
break;
|
|
case 160:
|
|
strcpy(_soi_target, "Jool");
|
|
break;
|
|
case 161:
|
|
strcpy(_soi_target, "Laythe");
|
|
break;
|
|
case 162:
|
|
strcpy(_soi_target, "Vall");
|
|
break;
|
|
case 163:
|
|
strcpy(_soi_target, "Tylo");
|
|
break;
|
|
case 164:
|
|
strcpy(_soi_target, "Bop");
|
|
break;
|
|
case 165:
|
|
strcpy(_soi_target, "Pol");
|
|
break;
|
|
case 170:
|
|
strcpy(_soi_target, "Eloo");
|
|
break;
|
|
default:
|
|
strcpy(_soi_target, "Unknown");
|
|
}
|
|
return _soi_target;
|
|
}
|
|
|
|
|
|
|
|
static void main_deck_init(void)
|
|
{
|
|
|
|
}
|
|
|
|
struct screen main_deck_screen = {
|
|
.draw = main_deck_draw,
|
|
.name = main_deck_name
|
|
};
|
|
|
|
struct task main_deck_task = {
|
|
.init = main_deck_init,
|
|
.run = main_deck_run,
|
|
.events = EV_BUTTON | EV_HEARTBEAT | EV_VESSELDATA,
|
|
.screen = &main_deck_screen,
|
|
.name = main_deck_name
|
|
};
|
|
|
|
static char * _float_to_str(float x, char *p) {
|
|
char *s = p + 20; // go to end of buffer
|
|
uint16_t decimals; // variable to store the decimals
|
|
int units; // variable to store the units (part to left of decimal place)
|
|
memset(p, ' ', 20);
|
|
if (x < 0.0) { // take care of negative numbers
|
|
decimals = (int)(x * -100) % 100; // make 1000 for 3 decimals etc.
|
|
units = (int)(-1 * x);
|
|
} else { // positive numbers
|
|
decimals = (int)(x * 100) % 100;
|
|
units = (int)x;
|
|
}
|
|
|
|
*--s = (decimals % 10) + '0';
|
|
decimals /= 10; // repeat for as many decimal places as you need
|
|
*--s = (decimals % 10) + '0';
|
|
*--s = '.';
|
|
|
|
while (units > 0) {
|
|
*--s = (units % 10) + '0';
|
|
units /= 10;
|
|
}
|
|
if (x < 0) *--s = '-'; // unary minus sign for negative numbers
|
|
return s;
|
|
}
|
|
float approx_sqrt(float x) {
|
|
float guess = x / 2.0;
|
|
float prev_guess;
|
|
float error = 1e-3; // set desired level of accuracy here
|
|
|
|
do {
|
|
prev_guess = guess;
|
|
guess = (guess + x / guess) / 2.0;
|
|
} while (fabs(guess - prev_guess) > error);
|
|
|
|
return guess;
|
|
}
|
|
#ifndef PI
|
|
#define PI 3.14159265
|
|
#endif
|
|
|
|
void draw_circle(int x, int y, int radius, uint8_t color)
|
|
{
|
|
|
|
int i, j;
|
|
uint8_t *screen = ui_get_screen(0);
|
|
int x0 = x - 10;
|
|
for (i = x - radius; i <= x + radius; i++) {
|
|
for (j = y - radius; j <= y + radius; j++) {
|
|
if ((i - x) * (i - x) + (j - y) * (j - y) <= radius * radius) {
|
|
ui_draw_h_segment(0, color, i, j, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ui_draw_circle_slice(uint32_t x, uint32_t y, uint32_t r, int alpha, int beta, uint8_t color) {
|
|
int i, j;
|
|
uint32_t start, end;
|
|
int cx = x;
|
|
int cy = y;
|
|
alpha += 90;
|
|
beta += 90;
|
|
|
|
if (alpha >= 360)
|
|
alpha-=360;
|
|
if (beta >= 360)
|
|
beta -= 360;
|
|
|
|
if (alpha < 0)
|
|
alpha += 360;
|
|
if (beta < 0)
|
|
beta += 360;
|
|
|
|
ui_draw_h_segment(0, color, x-1, y, 3);
|
|
|
|
if (alpha < beta) {
|
|
for (j = 0; j < r; j++) {
|
|
for (i = alpha; i < beta; i++) {
|
|
int px = cx + (int)(j * pcos(i));
|
|
int py = cy + (int)(j * psin(i));
|
|
if (px != cx || py != cy) {
|
|
ui_draw_h_segment(0, color, px, py, 1);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (j = 0; j < r; j++) {
|
|
for (i = alpha; i < 360; i++) {
|
|
int px = cx + (int)(j * pcos(i));
|
|
int py = cy + (int)(j * psin(i));
|
|
if (px != cx || py != cy) {
|
|
ui_draw_h_segment(0, color, px, py, 1);
|
|
}
|
|
}
|
|
for (i = 0; i < beta; i++) {
|
|
int px = cx + (int)(j * pcos(i));
|
|
int py = cy + (int)(j * psin(i));
|
|
if (px != cx || py != cy) {
|
|
ui_draw_h_segment(0, color, px, py, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#define ptan(a) psin(a)/pcos(a)
|
|
|
|
void ui_draw_circle_sector(int x, int y, int r, int px, int py, int rho, int include_center) {
|
|
int rho_norm = (0 - rho) + 90;
|
|
int i, j;
|
|
float m,q;
|
|
uint8_t upc, downc;
|
|
|
|
while (rho_norm < 0)
|
|
rho_norm+=360;
|
|
while (rho_norm >= 360)
|
|
rho_norm -= 360;
|
|
|
|
if ((rho == 0) || (rho == 180)) {
|
|
upc = BROWN;
|
|
downc = CYAN;
|
|
if (rho == 180){
|
|
upc = CYAN;
|
|
downc = BROWN;
|
|
}
|
|
for (i = x - r; i <= x + r; i++) {
|
|
for (j = y - r; j <= y + r; j++) {
|
|
if ((i - x) * (i - x) + (j - y) * (j - y) <= r * r) {
|
|
if (i > px)
|
|
ui_draw_h_segment(0, upc, i, j, 1);
|
|
else
|
|
ui_draw_h_segment(0, downc, i, j, 1);
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (rho > 0) {
|
|
upc = CYAN;
|
|
downc = BROWN;
|
|
}else {
|
|
upc = BROWN;
|
|
downc = CYAN;
|
|
}
|
|
|
|
m = ptan(rho_norm);
|
|
q = py - (m * px);
|
|
for (i = x - r; i <= x + r; i++) {
|
|
for (j = y - r; j <= y + r; j++) {
|
|
if ((i - x) * (i - x) + (j - y) * (j - y) <= r * r) {
|
|
if (j > (m * i + q))
|
|
ui_draw_h_segment(0, upc, i, j, 1);
|
|
else
|
|
ui_draw_h_segment(0, downc, i, j, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void draw_navball(int x, int y, int pitch, int roll) {
|
|
static int last_p_navball = -400;
|
|
static int last_r_navball = - 400;
|
|
|
|
if ((last_p_navball == pitch) && (last_r_navball == roll))
|
|
return;
|
|
ui_fill_area(0, BLACK, 150, 120, 320, 200);
|
|
last_p_navball = pitch;
|
|
last_r_navball = roll;
|
|
if (pitch > 45 && pitch < 135) {
|
|
draw_circle(x,y, 40, CYAN);
|
|
} else if (pitch < -45 && pitch > -135) {
|
|
draw_circle(x,y, 40, BROWN);
|
|
} else if (pitch == 0) {
|
|
int a = 0 - roll;
|
|
int b = a + 180;
|
|
|
|
ui_draw_circle_slice(x,y, 40, a, b, CYAN);
|
|
ui_draw_circle_slice(x,y, 40, b, a, BROWN);
|
|
} else {
|
|
uint32_t px, py;
|
|
px = x + 40 * psin(pitch) * pcos(roll);
|
|
py = y - 40 * psin(pitch) * psin(roll);
|
|
ui_draw_circle_sector(x, y, 40, px, py, roll, 1);
|
|
}
|
|
ui_draw_h_segment(0, ORANGE, x, y - 6, 5);
|
|
ui_draw_h_segment(0, ORANGE, x, y + 1, 5);
|
|
ui_draw_h_segment(0, ORANGE, x + 1, y - 2, 3);
|
|
ui_draw_h_segment(0, ORANGE, x + 1, y + 1, 3);
|
|
ui_draw_h_segment(0, ORANGE, x + 2, y, 1);
|
|
|
|
}
|
|
|
|
static void fuel_display(unsigned x, unsigned y, unsigned fuel, unsigned fuel_tot, char *label, int col)
|
|
{
|
|
unsigned tx = x;
|
|
unsigned ty = y;
|
|
unsigned i;
|
|
unsigned pct;
|
|
if (!vdata_valid)
|
|
return;
|
|
|
|
pct = fuel * 100 / fuel_tot;
|
|
|
|
ui_fill_area(0, BLACK, tx - 10, ty + 100, tx + 8, ty + 110);
|
|
ui_fill_area(0, BLACK, tx, ty, tx + 8, ty + 100);
|
|
ui_text_at(0, col, tx - 10, ty + 100, label);
|
|
for (i = 0; i < 100; i++) {
|
|
if (pct < 10)
|
|
col = RED;
|
|
if (pct > i) {
|
|
ui_fill_area(0, col, tx, ty + 100 - i, tx + 8, ty + 101 - i);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void avionics_display(controlPacket_t *cp)
|
|
{
|
|
|
|
uint32_t throttle, potr;
|
|
int32_t pitch, yaw, roll;
|
|
int i;
|
|
int tx = 322;
|
|
int ty = 150;
|
|
/* Throttle display */
|
|
pot_read(NULL, &potr);
|
|
throttle = ((potr * 100) / 4096);
|
|
|
|
ui_fill_area(0, BLACK, 245, 250, 332, 270);
|
|
ui_fill_area(0, BLACK, tx, ty, tx + 10, ty + 100);
|
|
ui_text_at(0, YELLOW, 245, 250, "Throttle:");
|
|
ui_text_at(0, YELLOW, 265, 260, ui_printn((potr * 100) / 4096));
|
|
for (i = 0; i < 100; i++) {
|
|
int col = YELLOW;
|
|
if (i > 90)
|
|
col = RED;
|
|
if (throttle > i) {
|
|
ui_fill_area(0, col, tx, ty + 100 - i, tx + 10, ty + 101 - i);
|
|
}
|
|
}
|
|
cp->Throttle = (potr * 1000) / 4096;
|
|
|
|
if (show_pitch_roll_yaw) {
|
|
unsigned px, py, rx,ry, yx, yy;
|
|
int col = GREEN;
|
|
int labelcol = GREEN;
|
|
char label[15];
|
|
px = 55;
|
|
py = 70;
|
|
rx = 2;
|
|
ry = 75;
|
|
yx = 2;
|
|
yy = 110;
|
|
ui_fill_area(0, 238, 2, 52, 103, 138);
|
|
|
|
|
|
/* Pitch display */
|
|
pitch = 0 - (cp->Pitch / 50);
|
|
snprintf(label, 15, "P %d", pitch);
|
|
ui_text_at(0, labelcol, px + 10, py + 20, label);
|
|
ui_fill_area(0, 235, px, py, px + 10, py + 40);
|
|
for (i = -20; i < 0; i++) {
|
|
if (pitch < i) {
|
|
ui_fill_area(0, col, px, py + 20 + i, px + 10, py + 21 + i);
|
|
}
|
|
}
|
|
for (i = 0; i < 20; i++) {
|
|
if (pitch > i) {
|
|
ui_fill_area(0, col, px, py + 20 + i, px + 10, py + 21 + i);
|
|
}
|
|
}
|
|
ui_fill_area(0, RED, px - 2, py + 20, px + 12, py + 21);
|
|
|
|
/* Roll display */
|
|
roll = (cp->Roll / 50);
|
|
snprintf(label, 15, "R %d", roll);
|
|
ui_text_at(0, labelcol, rx, ry - 10, label);
|
|
ui_fill_area(0, 235, rx, ry, rx + 40, ry + 10);
|
|
for (i = -20; i < 0; i++) {
|
|
if (roll < i) {
|
|
ui_fill_area(0, col, rx + 20 + i, ry, rx + 21 + i, ry + 10);
|
|
}
|
|
}
|
|
for (i = 0; i < 20; i++) {
|
|
if (roll > i) {
|
|
ui_fill_area(0, col, rx + 20 + i, ry, rx + 21 + i, ry + 10);
|
|
}
|
|
}
|
|
ui_fill_area(0, RED, rx + 20, ry - 2, rx + 21, ry + 12);
|
|
|
|
/* Yaw display */
|
|
yaw = (cp->Yaw / 50);
|
|
snprintf(label, 15, "Y %d", yaw);
|
|
ui_text_at(0, labelcol, yx, yy - 10, label);
|
|
ui_fill_area(0, 235, yx, yy, yx + 40, yy + 10);
|
|
for (i = -20; i < 0; i++) {
|
|
if (yaw < i) {
|
|
ui_fill_area(0, col, yx + 20 + i, yy, yx + 21 + i, yy + 10);
|
|
}
|
|
}
|
|
for (i = 0; i < 20; i++) {
|
|
if (yaw > i) {
|
|
ui_fill_area(0, col, yx + 20 + i, yy, yx + 21 + i, yy + 10);
|
|
}
|
|
}
|
|
ui_fill_area(0, RED, yx + 20, yy - 2, yx + 21, yy + 12);
|
|
} else
|
|
ui_fill_area(0, 235, 1, 51, 104, 138);
|
|
|
|
}
|
|
|
|
static void navi_display(void)
|
|
{
|
|
|
|
char Status[100] = "";
|
|
char Points[100] = "";
|
|
int ralt = (int)cur_vdata->RAlt;
|
|
int i = 0;
|
|
char hdg_bar[30] = "";
|
|
int hdg_dec, hdg_ref;
|
|
unsigned x_alt, y_alt;
|
|
int vvi;
|
|
uint8_t pointcolor;
|
|
|
|
|
|
if (((int)cur_vdata->VVI == 0) && ((int)cur_vdata->RAlt < 10)) {
|
|
strcpy(Status, "Landed at ");
|
|
} else if ((int)cur_vdata->e != 0) {
|
|
strcpy(Status, "Escaping from ");
|
|
} else if ((int) cur_vdata->PE < 0) {
|
|
strcpy(Status, "In flight over ");
|
|
} else {
|
|
strcpy(Status, "Orbiting ");
|
|
}
|
|
strcat(Status, soi_target(cur_vdata->SOINumber));
|
|
if ((int)(cur_vdata->PE < 0)){
|
|
snprintf(Points, 100, "Apo: %d, Peri: Negative", (int)(cur_vdata->AP));
|
|
pointcolor = PURPLE;
|
|
} else {
|
|
snprintf(Points, 100, "Apo: %d, Peri: %d",
|
|
(int)(cur_vdata->AP),
|
|
(int)(cur_vdata->PE));
|
|
pointcolor = CYAN;
|
|
}
|
|
|
|
ui_fill_area(0, BLACK, 140, 20, 380, 60);
|
|
ui_text_at(0, WHITE, 150, 20, Status);
|
|
ui_text_at(0, pointcolor, 150, 30, Points);
|
|
|
|
/* Navball */
|
|
draw_navball(160, 233, (int)cur_vdata->Pitch, (int)cur_vdata->Roll);
|
|
|
|
/* Altimeter */
|
|
x_alt = 105;
|
|
y_alt = 99;
|
|
ui_fill_area(0, DARKGREY, x_alt, y_alt, x_alt + 45, y_alt + 101);
|
|
if (ralt < 100000) {
|
|
ui_fill_area(0, BLACK, x_alt+45, y_alt, x_alt + 55, y_alt + 101);
|
|
for (i = 0; i < 100; i+=10)
|
|
ui_fill_area(0, DARKGREY, x_alt + 46, (y_alt + 99 - i), x_alt + 54, (y_alt + 101) - i);
|
|
i = ralt / 1000;
|
|
ui_fill_area(0, GREEN, x_alt + 45, (y_alt + 101) - i, x_alt + 55, (y_alt + 101));
|
|
ui_fill_area(0, BLACK, x_alt, (y_alt + 90) - i, x_alt + 50, (y_alt + 100) - i);
|
|
ui_text_at(0, WHITE, x_alt, (y_alt + 90) - i, ui_printn(ralt));
|
|
ui_text_at(0, WHITE, x_alt + 40, (y_alt + 90) - i, "m");
|
|
ui_fill_area(0, BRIGHT(GREEN), x_alt + 20, (y_alt + 101) - i, x_alt + 55, (y_alt + 102) - i);
|
|
}
|
|
ui_fill_area(0, WHITE, x_alt + 55, y_alt + 60, x_alt + 70, y_alt + 61);
|
|
vvi = (int)(cur_vdata->VVI);
|
|
if (vvi > 100)
|
|
vvi = 100;
|
|
if (vvi < -100)
|
|
vvi = -100;
|
|
|
|
if (vvi > 0) {
|
|
ui_fill_area(0, BRIGHT(GREEN), x_alt+56, y_alt + 60 - (vvi / 4), x_alt +60, y_alt + 61);
|
|
} else {
|
|
ui_fill_area(0, BRIGHT(RED), x_alt+56, y_alt + 60, x_alt +60, (y_alt + 60) - (vvi / 4));
|
|
}
|
|
|
|
|
|
/* Flight Data */
|
|
char pitch_s[6], roll_s[6], hdg_s[4] = "000";
|
|
ui_fill_area(0, BLACK, 155, 100, 320, 120);
|
|
|
|
ui_fill_area(0, BLACK, 222, 140, 246, 148);
|
|
snprintf(hdg_s, 4, "%03d", (int)(cur_vdata->Heading));
|
|
ui_text_at(0, WHITE, 222, 140, hdg_s);
|
|
|
|
ui_text_at(0, GREEN, 205, 110, "SPD");
|
|
ui_text_at(0, WHITE, 235, 110, ui_printn((int)(cur_vdata->IAS)));
|
|
|
|
|
|
/* Heading bar */
|
|
ui_fill_area(0, BLACK, 150, 200, 320, 220);
|
|
hdg_ref = ((int)cur_vdata->Heading) - 10;
|
|
if (hdg_ref < 0)
|
|
hdg_ref += 360;
|
|
for (i = 0; i < 20; i++) {
|
|
if (((i + hdg_ref) % 10) == 9) {
|
|
int hdg_pr = (hdg_ref + 1 + i) / 10 * 10;
|
|
if (hdg_pr >= 360)
|
|
hdg_pr -= 360;
|
|
snprintf(hdg_bar + i, 4,"%03d", hdg_pr);
|
|
i += 2;
|
|
continue;
|
|
}
|
|
else if (((i + hdg_ref) % 5) == 0) {
|
|
hdg_bar[i] = '|';
|
|
} else {
|
|
hdg_bar[i] = '.';
|
|
}
|
|
}
|
|
hdg_bar[21] = '\0';
|
|
ui_text_at(0, WHITE, 150, 200, " |");
|
|
ui_text_at(0, WHITE, 150, 210, hdg_bar);
|
|
|
|
}
|
|
|
|
static int button = -1;
|
|
#define BUTTON_THRESHOLD 2
|
|
|
|
static void main_deck_run(uint32_t event, void *arg)
|
|
{
|
|
int32_t x, y;
|
|
uint32_t torque;
|
|
struct sample *s;
|
|
int ts;
|
|
|
|
int throttle = 0;
|
|
int pitch = 0, roll = 0, yaw = 0;
|
|
|
|
int main_ctrl = 0;
|
|
|
|
static int sas = 0;
|
|
static int rcs = 0;
|
|
static int brk = 0;
|
|
static int gear = 0;
|
|
static int light = 0;
|
|
static uint8_t navmode = 0;
|
|
|
|
int i;
|
|
char btn_str[6];
|
|
int staging = 0;
|
|
controlPacket_t cp = {};
|
|
|
|
if (screen_get_focus() != &main_deck_screen)
|
|
return;
|
|
if (ui_menu_is_on()) {
|
|
if (event & EV_BUTTON)
|
|
ui_redraw(EV_BUTTON);
|
|
return;
|
|
}
|
|
ts = input_detect_touch();
|
|
if (ts == TS_TOUCH_NONE) {
|
|
} else {
|
|
event |= EV_BUTTON;
|
|
button = 12;
|
|
}
|
|
if (event & EV_VESSELDATA) {
|
|
static int ev_data_ctr = 0;
|
|
if ((++ev_data_ctr == 10) || (vdata_valid == 0)) {
|
|
brk = (cur_vdata->ActionGroups & (1 << 4)) >> 4;
|
|
gear = (cur_vdata->ActionGroups & (1 << 3)) >> 3;
|
|
light = (cur_vdata->ActionGroups & (1 << 2)) >> 2;
|
|
rcs = (cur_vdata->ActionGroups & (1 << 6)) >> 6;
|
|
sas = (cur_vdata->ActionGroups & (1 << 7)) >> 7;
|
|
navmode = cur_vdata->NavballSASMode;
|
|
ev_data_ctr = 0;
|
|
}
|
|
vdata_valid = 1;
|
|
navi_display();
|
|
clear_event(EV_VESSELDATA);
|
|
}
|
|
if (event & EV_BUTTON) {
|
|
if (button < 0)
|
|
button = ui_process_button_pressed();
|
|
switch(button) {
|
|
case 12: /* TS */
|
|
show_pitch_roll_yaw = !!!show_pitch_roll_yaw;
|
|
break;
|
|
|
|
case BUTTON_DPADU:
|
|
cp.Pitch = -1000;
|
|
break;
|
|
case BUTTON_DPADD:
|
|
cp.Pitch = 1000;
|
|
break;
|
|
case BUTTON_DPADL:
|
|
cp.Yaw = -1000;
|
|
break;
|
|
case BUTTON_DPADR:
|
|
cp.Yaw = 1000;
|
|
break;
|
|
case 7:
|
|
ui_menu(1);
|
|
ui_redraw(EV_NONE);
|
|
break;
|
|
case 10:
|
|
if (sas)
|
|
navmode++;
|
|
if ((navmode & 0xF) > 10) {
|
|
navmode &= 0xF0;
|
|
navmode |= 0x01;
|
|
}
|
|
break;
|
|
case 8:
|
|
if (vdata_valid)
|
|
gear = !(((cur_vdata->ActionGroups & (1 << 3)) >> 3));
|
|
break;
|
|
case 9:
|
|
if (vdata_valid)
|
|
light = !light;
|
|
break;
|
|
case 5:
|
|
if (vdata_valid)
|
|
brk = !(((cur_vdata->ActionGroups & (1 << 4)) >> 4));
|
|
break;
|
|
case 4:
|
|
staging++;
|
|
break;
|
|
}
|
|
button = -1;
|
|
clear_event(EV_BUTTON);
|
|
}
|
|
|
|
|
|
/* Sample joystick */
|
|
joy_read(&x, &y);
|
|
pot_read(&torque, NULL);
|
|
|
|
x-=2048 + ROLL_CALIB;
|
|
y-=2048 + PITCH_CALIB;
|
|
x*=2000 * torque / 4096;
|
|
y*=2000 * torque / 4096;
|
|
x/=4096;
|
|
y/=4096;
|
|
if ((x > 20) || (x < -20))
|
|
cp.Roll = x;
|
|
else
|
|
cp.Roll = 0;
|
|
|
|
if ((y > 20) || (y < -20))
|
|
cp.Pitch = y;
|
|
else
|
|
cp.Pitch = 0;
|
|
|
|
avionics_display(&cp);
|
|
|
|
if (vdata_valid) {
|
|
fuel_display(370, 100, (int)(cur_vdata->LiquidFuel), (int)(cur_vdata->LiquidFuelTot), "LF", YELLOW );
|
|
fuel_display(388, 100, (int)(cur_vdata->Oxidizer), (int)(cur_vdata->OxidizerTot), "Ox", CYAN);
|
|
fuel_display(406, 100, (int)(cur_vdata->SolidFuel), (int)(cur_vdata->SolidFuelTot), "SF", GREY);
|
|
fuel_display(424, 100, (int)(cur_vdata->ECharge), (int)(cur_vdata->EChargeTot), "el" , BRIGHT(GREEN));
|
|
fuel_display(442, 100, (int)(cur_vdata->XenonGas), (int)(cur_vdata->XenonGasTot), "Xe" , PINK);
|
|
|
|
if ((cur_vdata->ActionGroups & (1 << 1)) == (1 << 1))
|
|
fuel_display(32, 150, (int)(cur_vdata->MonoProp), (int)(cur_vdata->MonoPropTot), "MP", BRIGHT(YELLOW));
|
|
else
|
|
ui_fill_area(0, DARKGREY, 20, 150, 50, 280);
|
|
|
|
if ((cur_vdata->Density > 0)) {
|
|
int dens = (int)(cur_vdata->Density * 100);
|
|
if (dens > 100)
|
|
dens = 100;
|
|
fuel_display (50, 150, dens, 100, "At", 87);
|
|
fuel_display (68, 150, (int)(cur_vdata->IntakeAir),(int)(cur_vdata->IntakeAirTot), "Ai", CYAN);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/* Lamps */
|
|
ui_fill_area(0, 242, 35, 0, 64, 27);
|
|
ui_fill_area(0, light?58:233, 38, 0, 64, 24);
|
|
ui_text_at (0, (light?BLACK:238), 38, 8, "LIG");
|
|
|
|
ui_fill_area(0, 242, 65, 0, 94, 27);
|
|
ui_fill_area(0, gear?28:233, 68, 0, 94, 24);
|
|
ui_text_at (0, (gear?BLACK:238), 68, 8, "GEA");
|
|
|
|
ui_fill_area(0, 242, 95, 0, 124, 27);
|
|
ui_fill_area(0, brk?BLOOD:233, 98, 0, 124, 24);
|
|
ui_text_at (0, (brk?WHITE:238), 98, 8, "(!)");
|
|
|
|
/* Switches */
|
|
sas = input_get_swr()?1:0;
|
|
rcs = input_get_swl()?1:0;
|
|
if (sas == 0) {
|
|
navmode &= 0xF0;
|
|
}
|
|
ui_fill_area(0, 242, 447, 0, 474, 28);
|
|
ui_fill_area(0, sas?122:233, 450, 0, 474, 24);
|
|
ui_text_at (0, (sas?BLUE:238), 450, 8, "SAS");
|
|
|
|
ui_fill_area(0, 242, 3, 0, 30, 28);
|
|
ui_fill_area(0, rcs?GREEN:235, 6, 0, 30, 24);
|
|
|
|
ui_text_at (0, rcs?BRIGHT(GREEN):238, 6, 8, "RCS");
|
|
|
|
cp.id = 101;
|
|
cp.NavBallSASMode = navmode;
|
|
|
|
if (!rcs)
|
|
staging = 0;
|
|
|
|
if (vdata_valid) {
|
|
cp.MainControls = ((sas << 7) | (rcs << 6) | (light << 5) | (gear << 4) | (brk << 3) | (staging << 0));
|
|
ksp_serial_send(&cp, sizeof(cp));
|
|
}
|
|
|
|
if (sas)
|
|
uled_on(4);
|
|
else
|
|
uled_off(4);
|
|
if (rcs)
|
|
uled_on(5);
|
|
else
|
|
uled_off(5);
|
|
if(light)
|
|
uled_on(0);
|
|
else
|
|
uled_off(0);
|
|
if (gear)
|
|
uled_on(1);
|
|
else
|
|
uled_off(1);
|
|
if (brk)
|
|
uled_on(2);
|
|
else
|
|
uled_off(2);
|
|
|
|
}
|
|
|
|
static void main_deck_draw(void)
|
|
{
|
|
int i;
|
|
char btn_str[4] = "";
|
|
/* background to foreground */
|
|
ui_fill_area(0, DARKGREY, 0, 0, xres, yres);
|
|
ui_fill_area(0, WHITE, 0, 50, 105, 140); /* Pitch panel */
|
|
/* Logo & appname */
|
|
//image_at(0, logo, 5, 4, logox, logoy);
|
|
}
|
|
|
|
void main_deck_setup(void)
|
|
{
|
|
register_task(&main_deck_task);
|
|
register_screen(&main_deck_task, &main_deck_screen);
|
|
}
|