static void li_ion_work(struct work_struct *work)
{
struct li_ion_charger *li_ion;
int status;
int online;
li_ion = container_of(work, struct li_ion_charger, work.work);
online = gpio_get_value(li_ion->pdata->gpio) ^ li_ion->pdata->gpio_active_low;
pr_info("li_ion: li_ion_work: online=%d \n", online);
if (online != li_ion->online) {
status = online ? POWER_SUPPLY_STATUS_CHARGING : POWER_SUPPLY_STATUS_NOT_CHARGING;
if (status == POWER_SUPPLY_STATUS_NOT_CHARGING && is_ac_online())
status = POWER_SUPPLY_STATUS_FULL;
if (li_ion->status != status) {
pr_info("li_ion: update status: %s -> %s\n",
status_dbg(li_ion->status), status_dbg(status));
li_ion->status = status;
update_battery(li_ion, status);//
power_supply_changed(&li_ion->charger);
}
li_ion->online = online;
}
enable_irq(li_ion->irq);
}
void Display::update_all()
{
update_text(0);
update_mode(1);
update_battery(2);
update_gps(3);
//update_gps_sats(4);
update_prearm(4);
update_ekf(5);
}
static void li_ion_external_power_changed(struct power_supply *psy)
{
struct li_ion_charger *li_ion = psy_to_li_ion(psy);
if (li_ion->status == POWER_SUPPLY_STATUS_FULL && !is_ac_online()) {
pr_info("li_ion: ac offline: FULL -> NOT_CHARGING\n");
li_ion->status = POWER_SUPPLY_STATUS_NOT_CHARGING;
update_battery(li_ion, li_ion->status);//
power_supply_changed(&li_ion->charger);
} else
pr_info("li_ion: ac changed (skip)\n");
}
void display_battery(battery *b) {
char *battery_str;
if(update_battery(b)) {
battery_str = str_battery(b);
display("battery", b->name, b->label, battery_str, b->state);
}
else {
battery_str = malloc(16*sizeof(char));
snprintf(battery_str, 16, "No battery");
display("battery", b->name, b->label, battery_str, 2);
}
free(battery_str);
}
uint8_t send_data_from_battery_buffer(aci_state_t * aci_state)
{
if(battery_data_buffer[batt_data_buff_fetch_ptr] == NO_DATA)
{
return BUFFER_EMPTY;
}
else
{
update_battery(aci_state, battery_data_buffer[batt_data_buff_fetch_ptr]); //Send data from the buffer over the air
battery_data_buffer[batt_data_buff_fetch_ptr] = NO_DATA; //Erase the data from the buffer we just sent
//Move data-buffer fetch pointer location
if(batt_data_buff_fetch_ptr == (BATTERY_DATA_BUFF_SIZE - 1))
batt_data_buff_fetch_ptr = 0;
else
batt_data_buff_fetch_ptr++;
return SUCCESS;
}
}
void battery_handler(BatteryChargeState charge_state) {
update_battery(charge_state);
}
int RunMainSettings()
{
static int index = 0;
static int spy = 74;
int done = 0, y, i;
int max_entries = 8;
#ifdef FRAMESKIP
int menu_size = 12;
#else
int menu_size = 11;
#endif
static int offset_start = 0;
static int offset_end = menu_size > max_entries ? max_entries : menu_size;
char tmp[32];
int itmp;
g_dirty = 1;
while (!done) {
// Get time and battery every second
if (update_time()) {
update_battery();
g_dirty = 1;
}
// Parse input
readkey();
if (parsekey(DINGOO_B)) done = 1;
if (parsekey(DINGOO_UP, 1)) {
if (index > 0) {
index--;
if (index >= offset_start) spy -= 15;
if ((offset_start > 0) && (index < offset_start)) {
offset_start--;
offset_end--;
}
}
}
if (parsekey(DINGOO_DOWN, 1)) {
if (index < (menu_size-1)) {
index++;
if (index < offset_end) spy += 15;
if ((offset_end < menu_size) && (index >= offset_end)) {
offset_end++;
offset_start++;
}
}
}
if (parsekey(DINGOO_LEFT, 1) || parsekey(DINGOO_RIGHT, 1) || parsekey(DINGOO_A))
st_menu[index].update(g_key);
// Draw stuff
if( g_dirty )
{
draw_bg(vbuffer, g_bg);
DrawChar(vbuffer, SP_MAIN_SETTINGS, 40, 38);
// Draw time and battery every minute
DrawText(vbuffer, g_time, 148, 5);
DrawText(vbuffer, g_battery, 214, 5);
// Draw menu
for(i=offset_start,y=70;i < offset_end;i++,y+=15) {
DrawText(vbuffer, st_menu[i].name, 60, y);
g_config->getOption(st_menu[i].option, &itmp);
#ifdef FRACTIONAL_FRAMESKIP
if (!strncmp(st_menu[i].name, "Frameskip", 8)) {
int j;
if (itmp > 3) itmp = 3;
for (j=0;j<4;j++) if (itmp == frame_tag[j].val) break;
strcpy(tmp, frame_tag[j].str);
}
else
#endif
if (!strncmp(st_menu[i].name, "Custom palette", 6)) {
std::string palname;
g_config->getOption(st_menu[i].option, &palname);
// Remove path of string
const int sz = static_cast<int>(palname.size());
const int path_sz = palname.rfind("/",palname.size());
if (path_sz == sz) strncpy(tmp, palname.c_str(), 32);
else strncpy(tmp, palname.substr(path_sz + 1,sz - 1 - path_sz).c_str(), 32);
}
else
sprintf(tmp, "%d", itmp);
DrawText(vbuffer, tmp, 210, y);
}
// Draw info
DrawText(vbuffer, st_menu[index].info, 16, 225);
// Draw selector
DrawChar(vbuffer, SP_SELECTOR, 44, spy);
// Draw offset marks
if (offset_start > 0 ) DrawChar(vbuffer, SP_UPARROW, 274, 62);
if (offset_end < menu_size) DrawChar(vbuffer, SP_DOWNARROW, 274, 203);
g_dirty = 0;
}
dingoo_timer_delay(16);
// Update real screen
memcpy(dingoo_screen15, vbuffer, 320*240*sizeof(unsigned short));
}
g_dirty = 1;
return 0;
}
int RunSettingsMenu()
{
static int index = 0;
static int spy = 80;
int done = 0, y, i;
g_dirty = 1;
while (!done) {
// Get time and battery every second
if (update_time()) {
update_battery();
g_dirty = 1;
}
// Parse input
readkey();
if (parsekey(DINGOO_B)) done = 1;
if (parsekey(DINGOO_UP, 1)) {
if (index > 0) {
index--;
spy -= 16;
}
}
if (parsekey(DINGOO_DOWN, 1)) {
if (index < 3) {
index++;
spy += 16;
}
}
if (parsekey(DINGOO_A)) {
done = settings_menu[index].command();
}
// Must draw bg only when needed
// Draw stuff
if( g_dirty )
{
draw_bg(vbuffer, g_bg);
// Draw time and battery every minute
DrawText(vbuffer, g_time, 148, 5);
DrawText(vbuffer, g_battery, 214, 5);
DrawChar(vbuffer, SP_SETTINGS, 40, 38);
// Draw menu
for(i=0,y=76;i < 4;i++,y+=16) {
DrawText(vbuffer, settings_menu[i].name, 50, y);
}
// Draw info
DrawText(vbuffer, settings_menu[index].info, 16, 225);
// Draw selector
DrawChar(vbuffer, SP_SELECTOR, 34, spy);
g_dirty = 0;
}
dingoo_timer_delay(16);
// Update real screen
memcpy(dingoo_screen15, vbuffer, 320*240*sizeof(unsigned short));
}
// Must update emulation core and drivers
UpdateEMUCore(g_config);
FCEUD_DriverReset();
g_dirty = 1;
}
void force_update(void) {
update_battery(battery_state_service_peek());
toggle_bluetooth_icon(bluetooth_connection_service_peek());
}
void battery_handler(BatteryChargeState state) {
// Record the new battery level
update_battery(state.charge_percent);
}
void handle_init(void) {
// WINDOW //
mWindow = window_create();
if (mWindow == NULL) {
return;
}
window_stack_push(mWindow, true /* Animated */);
mWindowLayer = window_get_root_layer(mWindow);
window_set_background_color(mWindow, GColorWhite);
// BACKGROUND //
mBackgroundLayer = layer_create(layer_get_frame(mWindowLayer));
layer_add_child(mWindowLayer, mBackgroundLayer);
layer_set_update_proc(mBackgroundLayer, update_background_callback);
//BATTERY_ICONS
battery_image = gbitmap_create_with_resource(RESOURCE_ID_BATTERY_100);
GRect frame4 = (GRect) {
.origin = { .x = 50, .y = 82 },
.size = battery_image->bounds.size
};
battery_image_layer = bitmap_layer_create(frame4);
bitmap_layer_set_bitmap(battery_image_layer, battery_image);
layer_add_child(mWindowLayer, bitmap_layer_get_layer(battery_image_layer));
// FONTS //
//ResHandle res_d = resource_get_handle(RESOURCE_ID_SMALL_26);
ResHandle res_t = resource_get_handle(RESOURCE_ID_BIG_52);
ResHandle res_temp = resource_get_handle(RESOURCE_ID_MEDIUM_34);
//ResHandle res_hl = resource_get_handle(RESOURCE_ID_SMALL_22);
//mDateFont = fonts_load_custom_font(res_d);
mTimeFont = fonts_load_custom_font(res_t);
mTemperatureFont = fonts_load_custom_font(res_temp);
//mHighLowFont = fonts_load_custom_font(res_hl);
// TIME LAYER //
mTimeLayer = layer_create(layer_get_frame(mWindowLayer));
layer_add_child(mWindowLayer, mTimeLayer);
// TIME HOUR LAYER //
mTimeHourLayer = text_layer_create(TIME_HOUR_FRAME);
text_layer_set_background_color(mTimeHourLayer, GColorClear);
text_layer_set_text_color(mTimeHourLayer, GColorBlack);
text_layer_set_font(mTimeHourLayer, mTimeFont);
text_layer_set_text_alignment(mTimeHourLayer, GTextAlignmentRight);
layer_add_child(mTimeLayer, text_layer_get_layer(mTimeHourLayer));
// TIME SEPARATOR LAYER //
mTimeSeparatorLayer = text_layer_create(TIME_SEP_FRAME);
text_layer_set_background_color(mTimeSeparatorLayer, GColorClear);
text_layer_set_text_color(mTimeSeparatorLayer, GColorBlack);
text_layer_set_font(mTimeSeparatorLayer, mTimeFont);
text_layer_set_text_alignment(mTimeSeparatorLayer, GTextAlignmentCenter);
text_layer_set_text(mTimeSeparatorLayer, ":");
layer_add_child(mTimeLayer, text_layer_get_layer(mTimeSeparatorLayer));
// TIME MINUTES LAYER //
mTimeMinutesLayer = text_layer_create(TIME_MIN_FRAME);
text_layer_set_background_color(mTimeMinutesLayer, GColorClear);
text_layer_set_text_color(mTimeMinutesLayer, GColorBlack);
text_layer_set_font(mTimeMinutesLayer, mTimeFont);
text_layer_set_text_alignment(mTimeMinutesLayer, GTextAlignmentLeft);
layer_add_child(mTimeLayer, text_layer_get_layer(mTimeMinutesLayer));
// DATE LAYER //
mDateLayer = text_layer_create(DATE_FRAME);
text_layer_set_background_color(mDateLayer, GColorClear);
text_layer_set_text_color(mDateLayer, GColorBlack);
text_layer_set_font(mDateLayer, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));//mDateFont);
text_layer_set_text_alignment(mDateLayer, GTextAlignmentCenter);
layer_add_child(mWindowLayer, text_layer_get_layer(mDateLayer));
// WEATHER ICON //
mWeatherIconLayer = bitmap_layer_create(WEATHER_ICON_FRAME);
layer_add_child(mWindowLayer, bitmap_layer_get_layer(mWeatherIconLayer));
// TEMPERATURE //
mTemperatureLayer = text_layer_create(WEATHER_TEMP_FRAME);
text_layer_set_background_color(mTemperatureLayer, GColorClear);
text_layer_set_text_color(mTemperatureLayer, GColorBlack);
text_layer_set_font(mTemperatureLayer, mTemperatureFont); //fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD)); //
text_layer_set_text_alignment(mTemperatureLayer, GTextAlignmentCenter);
layer_add_child(mWindowLayer, text_layer_get_layer(mTemperatureLayer));
// HIGHLOW //
mHighLowLayer = text_layer_create(WEATHER_HL_FRAME);
text_layer_set_background_color(mHighLowLayer, GColorClear);
text_layer_set_text_color(mHighLowLayer, GColorBlack);
text_layer_set_font(mHighLowLayer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD)); //mHighLowFont);
text_layer_set_text_alignment(mHighLowLayer, GTextAlignmentCenter);
layer_add_child(mWindowLayer, text_layer_get_layer(mHighLowLayer));
weather_set_loading();
app_message_init();
time_t now = time(NULL);
struct tm *tick_time = localtime(&now);
mInitialMinute = (tick_time->tm_min % FREQUENCY_MINUTES);
handle_tick(tick_time, DAY_UNIT + HOUR_UNIT + MINUTE_UNIT + SECOND_UNIT);
tick_timer_service_subscribe(SECOND_UNIT, handle_tick);
bluetooth_connection_service_subscribe(bluetooth_connection_callback);
update_battery(battery_state_service_peek());
battery_state_service_subscribe(&update_battery);
}
void vmisc_tasks()
{
uint8_t time_count,time_200ms;
portTickType ticks_now,ticks_old = 0;
uint16_t time_elapsed = 0;
modem_config();
ublox_init();
// debug_config(); //configure debug serial port
/*
* data from external sensors initialized, version M21
* can disable it by commenting here and changing dataFromInternalSensors from 0 to 1
* check externalPackets.h for more information
*/
if (!(dataFromInternalSensors))
/* initialize external sensors data UART3, debug port and this can't be enabled together */
externalDataPortInit();
RPM_config();
ADC_config();
ADC_SoftwareStartConv(ADC1);
ADC_3_config();
ADC_SoftwareStartConv(ADC3);
PWM_out_config();
for(;;)
{
if(WDT_status == 1)
{
IWDG_ReloadCounter();
WDT_status = 0; //clear it so that it can be set again if all is OK
}
if(xbee_tx_count>0) //enable TX interrupts if transmit data is present
USART_ITConfig(USART1, USART_IT_TXE, ENABLE);
if(gps_tx.count >0) //enable TX interrupts if transmit data is present
USART_ITConfig(USART2, USART_IT_TXE, ENABLE);
if(debug_tx_count >0) //enable TX interrupts if transmit data is present
USART_ITConfig(USART3, USART_IT_TXE, ENABLE);
parse_gps_data();
if(xbee_rx_count)
parse_modem_data();
if(xbee_fresh_data) //if received fresh data
{
calculate_xbee(); //call appropriate function based on received data
xbee_fresh_data = 0;
}
if(log_init_flag)
{
if(write_buff_to_card == 1) //if one buffer is full
{
res = f_open(&fil, file_name, FA_OPEN_ALWAYS | FA_WRITE |FA_READ);
f_lseek(&fil, cursor_pos);
if(log_buff_status == 1)
{
f_write(&fil, SD_buffer2.BUFFER, SD_buffer2.write_count, &bw);
cursor_pos += SD_buffer2.write_count;
}
else if(log_buff_status == 2)
{
f_write(&fil, SD_buffer1.BUFFER, SD_buffer1.write_count, &bw);
cursor_pos += SD_buffer1.write_count;
}
write_buff_to_card = 0;
f_close(&fil);
GPIOF->ODR ^= GPIO_Pin_12;
}
}
ticks_now = xTaskGetTickCount()*2;
if((ticks_now - ticks_old) >=100) //do the following every 100ms
{
time_elapsed = ticks_now - ticks_old;
rpm = pulse_cnt*2*60/MOTOR_POLES*(1000/time_elapsed);
pulse_cnt = 0;
ticks_old = ticks_now;
air_speed_indicator();
send_status();
if(link_count >= 5 ) //no data from more than 500ms
{
modem_link_active = 0; //indicate absence of GIB
link_count = 0;
}
else
link_count++;
if(time_200ms == 2) //do the following every 200ms
{
send_gps_data();
time_200ms = 0;
}
else
time_200ms++;
if(time_count == 5) //do the following every 500ms
{
queue_data(); //append debug data for transmission
update_battery();
update_RPM();
send_press_temp();
send_defections();
send_power_propulsion();
time_count = 0;
}
else
time_count++;
}
}
}
