uint8_t test_light(uint8_t ev, uint16_t lparam, void* rparam)
{
switch(ev)
{
case EVENT_WINDOW_CREATED:
data = 0;
break;
case EVENT_KEY_PRESSED:
{
switch(lparam)
{
case KEY_UP:
data++;
if (data > 16) data = 1;
break;
case KEY_DOWN:
data--;
if (data == 0) data = 16;
break;
case KEY_ENTER:
data = 0;
break;
}
backlight_on(data, 0);
window_invalid(NULL);
break;
}
case EVENT_WINDOW_PAINT:
{
char buf[32];
tContext *pContext = (tContext*)rparam;
GrContextForegroundSet(pContext, ClrBlack);
GrRectFill(pContext, &client_clip);
GrContextForegroundSet(pContext, ClrWhite);
GrContextFontSet(pContext, (tFont*)&g_sFontGothic18);
GrStringDraw(pContext, "Test Lights", -1, 32, 50, 0);
sprintf(buf, "Light Level: %d", data);
GrStringDraw(pContext, buf, -1, 5, 70, 0);
window_button(pContext, KEY_UP, "+");
window_button(pContext, KEY_DOWN, "-");
window_button(pContext, KEY_ENTER, "Reset");
break;
}
case EVENT_EXIT_PRESSED:
backlight_on(0, 0);
return 0; // return 0 to close the window
default:
return 0;
}
return 1;
}
static int
mce_sink_play (NSinkInterface *iface, NRequest *request)
{
const NProplist *props = n_request_get_properties (request);
(void) iface;
const gchar *pattern = NULL;
MceData *data = (MceData*) n_request_get_data (request, MCE_KEY);
g_assert (data != NULL);
if (n_proplist_get_bool (props, "mce.backlight_on"))
backlight_on ();
pattern = n_proplist_get_string (props, "mce.led_pattern");
if (pattern != NULL) {
data->pattern = g_strdup (pattern);
if (toggle_pattern (pattern, TRUE)) {
active_events = g_list_append(active_events, data);
} else {
g_free (data->pattern);
data->pattern = NULL;
}
}
return TRUE;
}
void ui_test_finish(bool b_success)
{
ui_test_done = true;
ui_test_result = b_success;
if (b_success) {
backlight_on();
}
}
void Lcd::setRgb(const uint16_t &red, const uint16_t &green, const uint16_t &blue)
{
m_oldRed = red;
m_oldGreen = green;
m_oldBlue = blue;
backlight_on();
}
static void init_tagcache(void)
{
bool clear = false;
#if CONFIG_CODEC == SWCODEC
long talked_tick = 0;
#endif
tagcache_init();
while (!tagcache_is_initialized())
{
int ret = tagcache_get_commit_step();
if (ret > 0)
{
#if CONFIG_CODEC == SWCODEC
/* hwcodec can't use voice here, as the database commit
* uses the audio buffer. */
if(global_settings.talk_menu
&& (talked_tick == 0
|| TIME_AFTER(current_tick, talked_tick+7*HZ)))
{
talked_tick = current_tick;
talk_id(LANG_TAGCACHE_INIT, false);
talk_number(ret, true);
talk_id(VOICE_OF, true);
talk_number(tagcache_get_max_commit_step(), true);
}
#endif
#ifdef HAVE_LCD_BITMAP
if (lang_is_rtl())
{
splashf(0, "[%d/%d] %s", ret, tagcache_get_max_commit_step(),
str(LANG_TAGCACHE_INIT));
}
else
{
splashf(0, "%s [%d/%d]", str(LANG_TAGCACHE_INIT), ret,
tagcache_get_max_commit_step());
}
#else
lcd_double_height(false);
lcd_putsf(0, 1, " DB [%d/%d]", ret,
tagcache_get_max_commit_step());
lcd_update();
#endif
clear = true;
}
sleep(HZ/4);
}
tagtree_init();
if (clear)
{
backlight_on();
show_logo();
}
}
int my_handler(struct binder_state *bs, struct binder_transaction_data *txn,
struct binder_io *msg, struct binder_io *reply)
{
printf("[led_service] my_handler\n");
switch(txn->code)
{
case 1: backlight_on(); break;
case 2: backlight_off(); break;
}
return 0;
}
void window_notify(const char* title, const char* msg, uint8_t buttons, char icon)
{
message_title = title;
message_subtitle = NULL;
message = msg;
message_buttons = buttons;
message_icon = icon;
skip = 0;
push_uid(SPECIAL, 0);
selectidx = 0;
motor_on(50, CLOCK_SECOND);
backlight_on(window_readconfig()->light_level, CLOCK_SECOND * 3);
if (state & STATE_ACTIVE)
window_invalid(NULL);
else
window_open(notify_process, NULL);
}
void init_lcd() {
TRISBbits.RB7 = 0;
TRISBbits.RB6 = 0;
TRISBbits.RB5 = 0;
TRISAbits.RA0 = 0;
TRISAbits.RA1 = 0;
TRISAbits.RA2 = 0;
TRISAbits.RA3 = 0;
RS = 0;
RW = 0;
E = 0;
delay_s(1);
nibble(0x03);
__delay_ms(5);
nibble(0x03);
__delay_ms(5);
nibble(0x03);
delay_10us(15);
nibble(0x02);
send_command(LCD_FUNCTIONSET | LCD_4BITMODE | LCD_2LINE | LCD_5x8DOTS);
send_command(LCD_DISPLAYCONTROL | LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF);
TRISCbits.RC0 = 0;
backlight_on();
clear();
home();
splash(SPLASH_MSG);
clear();
home();
backlight_off();
}
static void wmt_bl_notify_after(struct device *dev, int brightness)
{
backlight_on(brightness != 0);
}
// calibrate menu
void menu_calibrate(u8 at_poweron) {
u8 channel = 1;
u16 last_val = 0xffff;
u16 val;
u8 seg;
u8 bat_volts;
u16 update_time = 0;
u16 update_val = 0;
menu_adc_wakeup = 1;
// cleanup screen and disable possible low bat warning
buzzer_off();
if (at_poweron) buzzer_on(30, 30, 2);
else key_beep();
menu_battery_low = 0; // it will be set automatically again
battery_low_shutup = 0;
backlight_set_default(BACKLIGHT_MAX);
backlight_on();
lcd_clear();
btnra();
// show intro text
lcd_chars("CAL");
lcd_update();
delay_menu_always(2);
// show channel number and not-yet calibrated values
lcd_segment(LS_SYM_CHANNEL, LS_ON);
lcd_7seg(channel);
lcd_menu(LM_MODEL | LM_NAME | LM_REV | LM_TRIM | LM_DR | LM_EXP);
lcd_set_blink(LMENU, LB_SPC);
while (1) {
// check keys
if (btnl(BTN_BACK | BTN_ENTER)) break;
if (btn(BTN_END | BTN_ROT_ALL)) {
if (btn(BTN_END)) key_beep();
// change channel number
channel = (u8)menu_change_val(channel, 1, 4, 1, 1);
lcd_7seg(channel);
lcd_update();
update_time = 0;
}
else if (btn(BTN_ENTER)) {
// save calibrate value for channels 1 and 2
// select actual voltage for channel 4
if (channel == 1) {
key_beep();
val = ADC_OVS(steering);
if (val < CALIB_ST_LOW_MID) {
cg.calib_steering_left = val;
seg = LS_MENU_MODEL;
}
else if (val <= CALIB_ST_MID_HIGH) {
cg.calib_steering_mid = val;
seg = LS_MENU_NAME;
}
else {
cg.calib_steering_right = val;
seg = LS_MENU_REV;
}
lcd_segment(seg, LS_OFF);
lcd_update();
}
else if (channel == 2) {
key_beep();
val = ADC_OVS(throttle);
if (val < CALIB_TH_LOW_MID) {
cg.calib_throttle_fwd = val;
seg = LS_MENU_TRIM;
}
else if (val <= CALIB_TH_MID_HIGH) {
cg.calib_throttle_mid = val;
seg = LS_MENU_DR;
}
else {
cg.calib_throttle_bck = val;
seg = LS_MENU_EXP;
}
lcd_segment(seg, LS_OFF); // set corresponding LCD off
lcd_update();
}
else if (channel == 4) {
key_beep();
// allow to set actual battery voltage
lcd_segment(LS_SYM_DOT, LS_ON);
lcd_segment(LS_SYM_VOLTS, LS_ON);
bat_volts = (u8)(((u32)adc_battery * 100 + 300) / cg.battery_calib);
lcd_char_num3(bat_volts);
lcd_update();
while (1) {
btnra();
stop();
if (btnl(BTN_BACK) || btn(BTN_ENTER | BTN_END)) break;
if (btn(BTN_ROT_ALL)) {
if (btn(BTN_ROT_L)) bat_volts--;
else bat_volts++;
lcd_char_num3(bat_volts);
lcd_update();
}
}
key_beep();
lcd_segment(LS_SYM_DOT, LS_OFF);
lcd_segment(LS_SYM_VOLTS, LS_OFF);
last_val = 0xffff; // show ADC value
if (!btn(BTN_END)) {
// recalculate calibrate value for 10V
cg.battery_calib = (u16)(((u32)adc_battery * 100 + 40) / bat_volts);
if (btnl(BTN_BACK | BTN_ENTER)) break;
}
}
}
// show ADC value if other than last val
switch (channel) {
case 1:
val = ADC_OVS(steering);
break;
case 2:
val = ADC_OVS(throttle);
break;
case 3:
val = ADC_OVS(ch3);
break;
case 4:
val = adc_battery;
break;
default: // to eliminate compiler warning
val = 0;
}
// only update display every 1s
if (time_sec >= update_time) {
update_time = time_sec + 1;
update_val = val;
}
if (update_val != last_val) {
last_val = update_val;
lcd_char_num3(val);
lcd_update();
}
btnra();
stop();
}
menu_adc_wakeup = 0;
beep(60);
lcd_menu(0);
lcd_update();
config_global_save();
apply_global_config();
}
void window_notify_ancs(uint8_t command, uint32_t uid, uint8_t flag, uint8_t category)
{
if (command == 0) // add
{
if (lastmessageid != -1 && lastmessageid >= uid)
{
return;
}
message_title = NULL;
message = NULL;
push_uid(uid, (flag << 8) | category);
selectidx = 0;
motor_on(50, CLOCK_SECOND);
backlight_on(window_readconfig()->light_level, CLOCK_SECOND * 3);
lastmessageid = uid;
if (state & STATE_ACTIVE)
window_invalid(NULL);
else
window_open(notify_process, NULL);
fetch_content();
}
else if (command == 1)
{
if (state & STATE_ACTIVE)
{
// check if the current
if (uids[0] == uid)
{
fetch_content();
}
window_invalid(NULL);
motor_on(50, CLOCK_SECOND);
}
}
else if (command == 2) // remove
{
if (!(state & STATE_ACTIVE))
return;
uint8_t refresh = 0;
if (uids[0] == uid)
{
refresh = 1;
}
// find the item
int i;
for(i = 0; i < num_uids; i++)
{
if (uids[i] == uid)
break;
}
if (i == num_uids)
return;
for (int j = i ; j < num_uids; j++)
{
uids[j] = uids[j+1];
attributes[j] = attributes[j+1];
}
num_uids--;
if (refresh)
fetch_content();
}
}
static void button_event(int key, bool pressed)
{
int new_btn = 0;
static bool usb_connected = false;
if (usb_connected && key != USB_KEY)
return;
switch (key)
{
case USB_KEY:
if (!pressed)
{
usb_connected = !usb_connected;
if (usb_connected)
queue_post(&button_queue, SYS_USB_CONNECTED, 0);
else
queue_post(&button_queue, SYS_USB_DISCONNECTED, 0);
}
return;
#if (CONFIG_PLATFORM & PLATFORM_PANDORA)
case SDLK_LCTRL:
/* Will post SDL_USEREVENT in shutdown_hw() if successful. */
sys_poweroff();
break;
#endif
#ifdef HAS_BUTTON_HOLD
case SDLK_h:
if(pressed)
{
hold_button_state = !hold_button_state;
DEBUGF("Hold button is %s\n", hold_button_state?"ON":"OFF");
}
return;
#endif
#ifdef HAS_REMOTE_BUTTON_HOLD
case SDLK_j:
if(pressed)
{
remote_hold_button_state = !remote_hold_button_state;
DEBUGF("Remote hold button is %s\n",
remote_hold_button_state?"ON":"OFF");
}
return;
#endif
#if defined(IRIVER_H100_SERIES) || defined (IRIVER_H300_SERIES)
case SDLK_t:
if(pressed)
switch(_remote_type)
{
case REMOTETYPE_UNPLUGGED:
_remote_type=REMOTETYPE_H100_LCD;
DEBUGF("Changed remote type to H100\n");
break;
case REMOTETYPE_H100_LCD:
_remote_type=REMOTETYPE_H300_LCD;
DEBUGF("Changed remote type to H300\n");
break;
case REMOTETYPE_H300_LCD:
_remote_type=REMOTETYPE_H300_NONLCD;
DEBUGF("Changed remote type to H300 NON-LCD\n");
break;
case REMOTETYPE_H300_NONLCD:
_remote_type=REMOTETYPE_UNPLUGGED;
DEBUGF("Changed remote type to none\n");
break;
}
break;
#endif
case SDLK_KP0:
case SDLK_F5:
if(pressed)
{
sim_trigger_screendump();
return;
}
break;
#ifdef HAVE_TOUCHSCREEN
case SDLK_F4:
if(pressed)
{
touchscreen_set_mode(touchscreen_get_mode() == TOUCHSCREEN_POINT ? TOUCHSCREEN_BUTTON : TOUCHSCREEN_POINT);
printf("Touchscreen mode: %s\n", touchscreen_get_mode() == TOUCHSCREEN_POINT ? "TOUCHSCREEN_POINT" : "TOUCHSCREEN_BUTTON");
}
#endif
default:
#ifdef HAVE_TOUCHSCREEN
new_btn = key_to_touch(key, mouse_coords);
if (!new_btn)
#endif
new_btn = key_to_button(key);
break;
}
/* Call to make up for scrollwheel target implementation. This is
* not handled in the main button.c driver, but on the target
* implementation (look at button-e200.c for example if you are trying to
* figure out why using button_get_data needed a hack before).
*/
#if defined(BUTTON_SCROLL_FWD) && defined(BUTTON_SCROLL_BACK)
if((new_btn == BUTTON_SCROLL_FWD || new_btn == BUTTON_SCROLL_BACK) &&
pressed)
{
/* Clear these buttons from the data - adding them to the queue is
* handled in the scrollwheel drivers for the targets. They do not
* store the scroll forward/back buttons in their button data for
* the button_read call.
*/
#ifdef HAVE_BACKLIGHT
backlight_on();
#endif
#ifdef HAVE_BUTTON_LIGHT
buttonlight_on();
#endif
queue_post(&button_queue, new_btn, 1<<24);
new_btn &= ~(BUTTON_SCROLL_FWD | BUTTON_SCROLL_BACK);
}
#endif
if (pressed)
btn |= new_btn;
else
btn &= ~new_btn;
}
/*--------------------------------------------------------------------------*/
int
main(int argc, char **argv)
{
/*
* Initalize hardware.
*/
msp430_cpu_init();
clock_init();
uart_init(9600); /* Must come before first printf */
/* xmem_init(); */
PRINTF("iWatch 0.10 build at " __TIME__ " " __DATE__ "\n");
UCSCTL8 &= ~BIT2;
/*
* Hardware initialization done!
*/
/*
* Initialize Contiki and our processes.
*/
process_init();
process_start(&etimer_process, NULL);
rtimer_init();
ctimer_init();
energest_init();
ENERGEST_ON(ENERGEST_TYPE_CPU);
backlight_init();
battery_init();
SPI_FLASH_Init();
if (system_testing())
{
clock_time_t t;
backlight_on(200, 0);
t = clock_seconds();
// sleep 1
while(clock_seconds() - t <= 3);
printf("$$OK BACKLIGHT\n");
t = clock_seconds();
while(clock_seconds() - t <= 3);
backlight_on(0, 0);
motor_on(200, 0);
// sleep 1s
t = clock_seconds();
while(clock_seconds() - t <= 3);
printf("$$OK MOTOR\n");
t = clock_seconds();
while(clock_seconds() - t <= 3);
motor_on(0, 0);
#if PRODUCT_W001
I2C_Init();
codec_init();
codec_bypass(1);
// sleep 1s
t = clock_seconds();
while(clock_seconds() - t <= 3);
printf("$$OK MIC\n");
// sleep 1s
t = clock_seconds();
while(clock_seconds() - t <= 3);
codec_bypass(0);
codec_shutdown();
#endif
}
int reason = CheckUpgrade();
window_init(reason);
button_init();
rtc_init();
CFSFontWrapperLoad();
system_init(); // check system status and do factor reset if needed
I2C_Init();
//codec_init();
//ant_init();
bluetooth_init();
#ifdef PRODUCT_W004
//bmx_init();
#else
mpu6050_init();
#endif
// check the button status
if (button_snapshot() & (1 << BUTTON_UP))
{
clock_time_t t;
// delay 1 second
// button up is pressed, we will set emerging flag
motor_on(200, CLOCK_SECOND * 2);
t = clock_seconds();
while(clock_seconds() - t <= 1);
if (button_snapshot() & (1 << BUTTON_UP))
system_setemerging();
motor_on(0, 0);
}
if (!system_retail())
{
bluetooth_discoverable(1);
}
#if PRODUCT_W001
if (system_testing())
ant_init(MODE_HRM);
#endif
system_restore();
// protocol_init();
// protocol_start(1);
process_start(&system_process, NULL);
/*
* This is the scheduler loop.
*/
msp430_dco_required = 0;
/*
check firmware update
*/
if (reason == 0xff)
{
printf("Start Upgrade\n");
Upgrade();
// never return if sucessfully upgrade
}
watchdog_start();
while(1) {
int r;
do {
/* Reset watchdog. */
watchdog_periodic();
r = process_run();
} while(r > 0);
/*
* Idle processing.
*/
int s = splhigh(); /* Disable interrupts. */
/* uart1_active is for avoiding LPM3 when still sending or receiving */
if(process_nevents() != 0) {
splx(s); /* Re-enable interrupts. */
} else {
static unsigned long irq_energest = 0;
/* Re-enable interrupts and go to sleep atomically. */
ENERGEST_OFF(ENERGEST_TYPE_CPU);
ENERGEST_ON(ENERGEST_TYPE_LPM);
/* We only want to measure the processing done in IRQs when we
are asleep, so we discard the processing time done when we
were awake. */
energest_type_set(ENERGEST_TYPE_IRQ, irq_energest);
watchdog_stop();
if (shutdown_mode)
{
system_shutdown(1); // never return
LPM4;
}
if (msp430_dco_required)
{
__low_power_mode_0();
}
else
{
__low_power_mode_3();
}
/* We get the current processing time for interrupts that was
done during the LPM and store it for next time around. */
__disable_interrupt();
irq_energest = energest_type_time(ENERGEST_TYPE_IRQ);
__enable_interrupt();
watchdog_start();
ENERGEST_OFF(ENERGEST_TYPE_LPM);
ENERGEST_ON(ENERGEST_TYPE_CPU);
}
}
}
static void handle_scroll_wheel(int new_scroll)
{
static const signed char scroll_state[4][4] = {
{0, 1, -1, 0},
{-1, 0, 0, 1},
{1, 0, 0, -1},
{0, -1, 1, 0}
};
static int prev_scroll = -1;
static int direction = 0;
static int count = 0;
static long next_backlight_on = 0;
int wheel_keycode = BUTTON_NONE;
int scroll;
static unsigned long wheel_delta = 1ul << 24;
static unsigned long wheel_velocity = 0;
static unsigned long last_wheel_usec = 0;
static int prev_keypost = BUTTON_NONE;
unsigned long usec;
unsigned long v;
if ( prev_scroll == -1 ) {
prev_scroll = new_scroll;
return;
}
scroll = scroll_state[prev_scroll][new_scroll];
prev_scroll = new_scroll;
if (direction != scroll) {
/* direction reversal or was hold - reset all */
direction = scroll;
count = 0;
prev_keypost = BUTTON_NONE;
wheel_velocity = 0;
wheel_delta = 1ul << 24;
return;
}
/* poke backlight every 1/4s of activity */
if (TIME_AFTER(current_tick, next_backlight_on)) {
backlight_on();
reset_poweroff_timer();
next_backlight_on = current_tick + HZ/4;
}
if (++count < WHEEL_BASE_SENSITIVITY)
return;
count = 0;
/* Mini 1st Gen wheel has inverse direction mapping
* compared to 1st..3rd Gen wheel. */
switch (direction) {
case 1:
wheel_keycode = BUTTON_SCROLL_FWD;
break;
case -1:
wheel_keycode = BUTTON_SCROLL_BACK;
break;
default:
/* only happens if we get out of sync */
break;
}
/* have a keycode */
usec = USEC_TIMER;
v = usec - last_wheel_usec;
/* calculate deg/s based upon sensitivity-adjusted interrupt period */
if ((long)v <= 0) {
/* timer wrapped (no activity for awhile), skip acceleration */
v = 0;
wheel_delta = 1ul << 24;
}
else {
if (v > 0xfffffffful/WHEELCLICKS_PER_ROTATION) {
v = 0xfffffffful/WHEELCLICKS_PER_ROTATION; /* check overflow below */
}
v = 360000000ul*WHEEL_BASE_SENSITIVITY / (v*WHEELCLICKS_PER_ROTATION);
if (v > 0xfffffful)
v = 0xfffffful; /* limit to 24 bits */
}
if (v < WHEEL_SMOOTHING_VELOCITY) {
/* very slow - no smoothing */
wheel_velocity = v;
/* ensure backlight never gets stuck for an extended period if tick
* wrapped such that next poke is very far ahead */
next_backlight_on = current_tick - 1;
}
else {
/* some velocity filtering to smooth things out */
wheel_velocity = (7*wheel_velocity + v) / 8;
}
if (queue_empty(&button_queue)) {
int key = wheel_keycode;
if (v >= WHEEL_REPEAT_VELOCITY && prev_keypost == key) {
/* quick enough and same key is being posted more than once in a
* row - generate repeats - use unsmoothed v to guage */
key |= BUTTON_REPEAT;
}
prev_keypost = wheel_keycode;
/* post wheel keycode with wheel data */
queue_post(&button_queue, key,
(wheel_velocity >= WHEEL_ACCEL_START ? (1ul << 31) : 0)
| wheel_delta | wheel_velocity);
/* message posted - reset delta */
wheel_delta = 1ul << 24;
}
else {
/* skipped post - increment delta and limit to 7 bits */
wheel_delta += 1ul << 24;
if (wheel_delta > (0x7ful << 24))
wheel_delta = 0x7ful << 24;
}
last_wheel_usec = usec;
}
int
main(int argc, char **argv) {
char curs[] = {0, 0, 0, 0, 0, 0, 0, 0};
char buf[32], passwd[256];
int num, screen;
#ifndef HAVE_BSD_AUTH
const char *pws;
#endif
unsigned int len;
Bool running = True;
Cursor invisible;
Display *dpy;
KeySym ksym;
Pixmap pmap;
Window root, w;
XColor black, dummy;
XEvent ev;
XSetWindowAttributes wa;
if((argc == 2) && !strcmp("-v", argv[1]))
die("slock-"VERSION", © 2006-2008 Anselm R Garbe\n");
else if(argc != 1)
die("usage: slock [-vb]\n");
backlight_of();
#ifndef HAVE_BSD_AUTH
pws = get_password();
#endif
if(!(dpy = XOpenDisplay(0)))
die("slock: cannot open display\n");
screen = DefaultScreen(dpy);
root = RootWindow(dpy, screen);
/* init */
wa.override_redirect = 1;
wa.background_pixel = BlackPixel(dpy, screen);
w = XCreateWindow(dpy, root, 0, 0, DisplayWidth(dpy, screen), DisplayHeight(dpy, screen),
0, DefaultDepth(dpy, screen), CopyFromParent,
DefaultVisual(dpy, screen), CWOverrideRedirect | CWBackPixel, &wa);
XAllocNamedColor(dpy, DefaultColormap(dpy, screen), "black", &black, &dummy);
pmap = XCreateBitmapFromData(dpy, w, curs, 8, 8);
invisible = XCreatePixmapCursor(dpy, pmap, pmap, &black, &black, 0, 0);
XDefineCursor(dpy, w, invisible);
XMapRaised(dpy, w);
for(len = 1000; len; len--) {
if(XGrabPointer(dpy, root, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
GrabModeAsync, GrabModeAsync, None, invisible, CurrentTime) == GrabSuccess)
break;
usleep(1000);
}
if((running = running && (len > 0))) {
for(len = 1000; len; len--) {
if(XGrabKeyboard(dpy, root, True, GrabModeAsync, GrabModeAsync, CurrentTime)
== GrabSuccess)
break;
usleep(1000);
}
running = (len > 0);
}
len = 0;
XSync(dpy, False);
/* main event loop */
while(running && !XNextEvent(dpy, &ev)) {
if(len == 0 && DPMSCapable(dpy)) {
DPMSEnable(dpy);
DPMSForceLevel(dpy, DPMSModeOff);
}
if(ev.type == KeyPress) {
buf[0] = 0;
num = XLookupString(&ev.xkey, buf, sizeof buf, &ksym, 0);
if(IsKeypadKey(ksym)) {
if(ksym == XK_KP_Enter)
ksym = XK_Return;
else if(ksym >= XK_KP_0 && ksym <= XK_KP_9)
ksym = (ksym - XK_KP_0) + XK_0;
}
if(IsFunctionKey(ksym) || IsKeypadKey(ksym)
|| IsMiscFunctionKey(ksym) || IsPFKey(ksym)
|| IsPrivateKeypadKey(ksym))
continue;
switch(ksym) {
case XK_Return:
passwd[len] = 0;
#ifdef HAVE_BSD_AUTH
running = !auth_userokay(getlogin(), NULL, "auth-xlock", passwd);
#else
running = strcmp(crypt(passwd, pws), pws);
#endif
if (running != 0)
XBell(dpy, 100);
len = 0;
break;
case XK_Escape:
len = 0;
break;
case XK_BackSpace:
if(len)
--len;
break;
default:
if(num && !iscntrl((int) buf[0]) && (len + num < sizeof passwd)) {
memcpy(passwd + len, buf, num);
len += num;
}
break;
}
}
}
XUngrabPointer(dpy, CurrentTime);
XFreePixmap(dpy, pmap);
XDestroyWindow(dpy, w);
XCloseDisplay(dpy);
backlight_on();
return 0;
}
/*#####################################################*/
bool board_init()
{
core_init();
timer_init();
RtcInit();
/*-----------------------------------------------------*/
/* Set up the Uart 0 like debug interface with RxBuff = 256, TxBuff = 256, 115200b/s*/
Uart[0] = new_(new_uart);
Uart[0]->TxPin = Uart0_Tx_PinMux_E16;
Uart[0]->RxPin = Uart0_Rx_PinMux_E15;
Uart[0]->BaudRate = 115200;
Uart[0]->RxBuffSize = 256;
Uart[0]->TxBuffSize = 256;
Uart[0]->rxFifoTrigLevel = 1;
Uart[0]->txFifoTrigLevel = 1;
Uart[0]->UartNr = 0;
uart_open(Uart[0]);
DebugCom = Uart[0];
/*-----------------------------------------------------*/
LED[0] = gpio_assign(1, 21, GPIO_DIR_OUTPUT, false);
LED[1] = gpio_assign(1, 22, GPIO_DIR_OUTPUT, false);
LED[2] = gpio_assign(1, 23, GPIO_DIR_OUTPUT, false);
LED[3] = gpio_assign(1, 24, GPIO_DIR_OUTPUT, false);
/*-----------------------------------------------------*/
/* Display board message*/
#if defined(BOARD_MESSAGE)
UARTprintf(DebugCom, "Use %s Board.\n\r", BOARD_MESSAGE);
#endif
/*-----------------------------------------------------*/
/* Set up the Twi 0 to communicate with PMIC and the Onboard serial EEprom memory */
UARTPuts(DebugCom, "Setup TWI 0 with RxBuff = 258, TxBuff = 258....." , -1);
TWI[0] = new_(new_twi);
TWI[0]->SdaPin = Twi0_Sda_PinMux_C17;
TWI[0]->SclPin = Twi0_Scl_PinMux_C16;
TWI[0]->BaudRate = 100000;
TWI[0]->TwiNr = 0;
TWI[0]->Priority = 0;
TWI[0]->UseInterrupt = TRUE;
TWI[0]->RxBuffSize = 258;
TWI[0]->TxBuffSize = 258;
twi_open(TWI[0]);
UARTPuts(DebugCom, "OK.\n\r" , -1);
/*-----------------------------------------------------*/
if(!is_beaglebone()) return false;
/*-----------------------------------------------------*/
/* Set up the Twi 1 to communicate with PMIC and the Onboard serial EEprom memory */
UARTPuts(DebugCom, "Setup TWI 1 with RxBuff = 258, TxBuff = 258....." , -1);
TWI[1] = new_(new_twi);
TWI[1]->SdaPin = Twi1_Sda_PinMux_B16;
TWI[1]->SclPin = Twi1_Scl_PinMux_A16;
TWI[1]->BaudRate = 100000;
TWI[1]->TwiNr = 1;
TWI[1]->Priority = 0;
TWI[1]->UseInterrupt = TRUE;
TWI[1]->RxBuffSize = 258;
TWI[1]->TxBuffSize = 258;
twi_open(TWI[1]);
UARTPuts(DebugCom, "OK.\n\r" , -1);
/*-----------------------------------------------------*/
/* Set up the Twi 2 to communicate with PMIC and the Onboard serial EEprom memory */
UARTPuts(DebugCom, "Setup TWI 2 with RxBuff = 258, TxBuff = 258....." , -1);
TWI[2] = new_(new_twi);
TWI[2]->SdaPin = Twi2_Sda_PinMux_D18;
TWI[2]->SclPin = Twi2_Scl_PinMux_D17;
TWI[2]->BaudRate = 100000;
TWI[2]->TwiNr = 2;
TWI[2]->Priority = 0;
TWI[2]->UseInterrupt = TRUE;
TWI[2]->RxBuffSize = 258;
TWI[2]->TxBuffSize = 258;
twi_open(TWI[2]);
UARTPuts(DebugCom, "OK.\n\r" , -1);
/*-----------------------------------------------------*/
beaglebone_detect_extension_boards();
/*-----------------------------------------------------*/
#if USE_ADXL345
ADXL345_1 = new_(new_adxl345);
ADXL345_1->MasterSlaveAddr = ADXL345_SLAVE_ADDR_ALT_0;
ADXL345_1->TwiStruct = TWI[2];
ADXL345_1->Calibration_X = -14;
ADXL345_1->Calibration_Y = 11;
ADXL345_1->Calibration_Z = 24;
ADXL345_1->FilterBuffSize = 4;
if(adxl345_init(ADXL345_1))
{
UARTPuts(DebugCom, "ADXL345 detected on TWI2.\n\r" , -1);
}
else
{
if(ADXL345_1) free(ADXL345_1);
UARTPuts(DebugCom, "ADXL345 not detected.\n\r" , -1);
}
#endif
/*-----------------------------------------------------*/
UARTPuts(DebugCom, "Init MMCSD0 .......", -1);
sdCtrl[0].SdNr = 0;
mmcsd_init(&sdCtrl[0], 0, 6, LED[0]);
UARTPuts(DebugCom, "OK.\n\r", -1);
mmcsd_idle(&sdCtrl[0]);
/*-----------------------------------------------------*/
eMMC_Res = gpio_assign(1, 20, GPIO_DIR_OUTPUT, false);
gpio_out(eMMC_Res, 0);
Sysdelay(10);
gpio_out(eMMC_Res, 1);
UARTPuts(DebugCom, "Init MMCSD1 .......", -1);
sdCtrl[1].SdNr = 1;
mmcsd_init(&sdCtrl[1], -1, -1, LED[0]);
UARTPuts(DebugCom, "OK.\n\r", -1);
mmcsd_idle(&sdCtrl[1]);
/*-----------------------------------------------------*/
#ifdef usb_1_msc
UARTPuts(DebugCom, "Init USBMSC1 Host.......", -1);
usb_msc_host_init(1, LED[2]);
UARTPuts(DebugCom, "OK.\n\r", -1);
usb_msc_host_idle(1);
#elif defined( usb_1_mouse ) && !defined( touch )
/*-----------------------------------------------------*/
UARTPuts(DebugCom, "Init USBMOUSE1 Host.......", -1);
usb_mouse_host_init(1);
UARTPuts(DebugCom, "OK.\n\r", -1);
#endif
/*-----------------------------------------------------*/
#if defined( usb_0_dev_msc ) && defined ( BridgeUsbDev0ToMmcSd0)
UARTPuts(DebugCom, "Bridge USBMSC0 Dev for MMCSD0 Interface.......", -1);
drv_rw_func.DriveStruct = &sdCtrl[0];
drv_rw_func.drv_ioctl_func = mmcsd_ioctl;
drv_rw_func.drv_r_func = mmcsd_read;
drv_rw_func.drv_w_func = mmcsd_write;
usb_msc_dev_init(0);
UARTPuts(DebugCom, "OK.\n\r", -1);
/*-----------------------------------------------------*/
#elif defined( usb_0_dev_msc ) && defined ( BridgeUsbDev0ToMmcSd1)
UARTPuts(DebugCom, "Bridge USBMSC0 Dev for MMCSD1 Interface.......", -1);
drv_rw_func.DriveStruct = &sdCtrl[1];
drv_rw_func.drv_ioctl_func = mmcsd_ioctl;
drv_rw_func.drv_r_func = mmcsd_read;
drv_rw_func.drv_w_func = mmcsd_write;
usb_msc_dev_init(0);
UARTPuts(DebugCom, "OK.\n\r", -1);
/*-----------------------------------------------------*/
#elif defined( usb_0_dev_msc ) && defined ( BridgeUsbDev0ToUsbHost1) && defined(usb_1_msc) && !defined(usb_1_mouse)
extern unsigned int g_ulMSCInstance0Usb1;//UsbMsc driver
UARTPuts(DebugCom, "Bridge USBMSC0 Dev for USBMSC1Host Interface.......", -1);
drv_rw_func.DriveStruct = (void *)g_ulMSCInstance0Usb1;
drv_rw_func.drv_ioctl_func = usb_msc_host_ioctl;
drv_rw_func.drv_r_func = usb_msc_host_read;
drv_rw_func.drv_w_func = usb_msc_host_write;
usb_msc_dev_init(0);
UARTPuts(DebugCom, "OK.\n\r", -1);
#endif
/*-----------------------------------------------------*/
#ifdef lcd
TouchScreen = new_(new_touchscreen);
TouchScreen->TwiStruct = TWI[1];
#endif
bool LCD3_Cape_Detected = false;
if(Board1ConfigData) if(!memcmp(Board1ConfigData + 4, "A0BeagleBone LCD3 CAPE", 22)) LCD3_Cape_Detected = true;
if(Board2ConfigData) if(!memcmp(Board2ConfigData + 4, "A0BeagleBone LCD3 CAPE", 22)) LCD3_Cape_Detected = true;
if(Board3ConfigData) if(!memcmp(Board3ConfigData + 4, "A0BeagleBone LCD3 CAPE", 22)) LCD3_Cape_Detected = true;
if(Board4ConfigData) if(!memcmp(Board4ConfigData + 4, "A0BeagleBone LCD3 CAPE", 22)) LCD3_Cape_Detected = true;
if(LCD3_Cape_Detected)
{
/*-----------------------------------------------------*/
HARDBTN[0] = gpio_assign(1, 16, GPIO_DIR_INPUT, false);
HARDBTN[1] = gpio_assign(1, 17, GPIO_DIR_INPUT, false);
HARDBTN[2] = gpio_assign(3, 19, GPIO_DIR_INPUT, false);
HARDBTN[3] = gpio_assign(1, 28, GPIO_DIR_INPUT, false);
HARDBTN[4] = gpio_assign(0, 7, GPIO_DIR_INPUT, false);
/*-----------------------------------------------------*/
LED[4] = gpio_assign(1, 28, GPIO_DIR_OUTPUT, false);
LED[5] = gpio_assign(1, 18, GPIO_DIR_OUTPUT, false);
/*-----------------------------------------------------*/
#ifdef lcd
ScreenBuff = new_(new_screen);
ScreenBuff->raster_timings = &lcd_S035Q01_beaglebone_exp;
ScreenBuff->BackLightLevel = 60;
ScreenBuff->PmicTwiModuleStruct = TWI[0];
screen_init(ScreenBuff);
UARTprintf(DebugCom, "LCD display initialize successful for %dx%d resolution, %d Bit bus.\n\r" , ScreenBuff->raster_timings->X, ScreenBuff->raster_timings->Y, ScreenBuff->raster_timings->bus_size);
TouchScreen->screen_max_x = (double)ScreenBuff->raster_timings->X;
TouchScreen->screen_max_y = (double)ScreenBuff->raster_timings->Y;
TouchScreen->pDisplay = ScreenBuff;
InitTouchScreen(TouchScreen);
UARTPuts(DebugCom, "Init calibration of LCD resistive touch screen....." , -1);
TouchCalibrate(TouchScreen, ScreenBuff);
UARTPuts(DebugCom, "OK.\n\r" , -1);
put_rectangle(ScreenBuff, 0, 0, ScreenBuff->raster_timings->X, ScreenBuff->raster_timings->Y, true, controls_color.Scren);
box_cache_clean(ScreenBuff, 0, 0, ScreenBuff->raster_timings->X, ScreenBuff->raster_timings->Y);
#endif
}
else
{
#ifdef lcd
if(ft5x06_init(TouchScreen, 0, 30))
{
UARTPuts(DebugCom, "Capacitive touch screen detected and set up successful.\n\r" , -1);
#endif
UARTPuts(DebugCom, "I suppose that is BeagleBone Multimedia cape from Chipsee.\n\r" , -1);
/*-----------------------------------------------------*/
HARDBTN[0] = gpio_assign(1, 19, GPIO_DIR_INPUT, false);
HARDBTN[1] = gpio_assign(1, 16, GPIO_DIR_INPUT, false);
HARDBTN[2] = gpio_assign(1, 17, GPIO_DIR_INPUT, false);
HARDBTN[3] = gpio_assign(0, 7, GPIO_DIR_INPUT, false);
//HARDBTN[4] = gpio_assign(1, 3, GPIO_DIR_INPUT, false); If you use BBB this pin is used by the DAT3 of eMMC onboard memory(if you want to use this pin you will use the eMMC in 1 bit data bus mode).
/*-----------------------------------------------------*/
#ifdef lcd
ScreenBuff = new_(new_screen);
ScreenBuff->raster_timings = &lcd_AT070TN92_beaglebone_exp;
ScreenBuff->BackLightPort = 1;
ScreenBuff->BackLightPin = 18;
screen_init(ScreenBuff);
TouchScreen->screen_max_x = ScreenBuff->raster_timings->X;
TouchScreen->screen_max_y = ScreenBuff->raster_timings->Y;
TouchScreen->pDisplay = ScreenBuff;
UARTprintf(DebugCom, "LCD display initialize successful for %dx%d resolution, %d Bit bus.\n\r" , ScreenBuff->raster_timings->X, ScreenBuff->raster_timings->Y, ScreenBuff->raster_timings->bus_size);
put_rectangle(ScreenBuff, 0, 0, ScreenBuff->raster_timings->X, ScreenBuff->raster_timings->Y, true, controls_color.Scren);
box_cache_clean(ScreenBuff, 0, 0, ScreenBuff->raster_timings->X, ScreenBuff->raster_timings->Y);
backlight_on(ScreenBuff);
}
else
{
//UARTPuts(DebugCom, "No display detected.\n\r" , -1);
//free_touchscreen(TouchScreen);
UARTPuts(DebugCom, "I suppose that is BeagleBone Multimedia cape from Chipsee.\n\r" , -1);
/*-----------------------------------------------------*/
HARDBTN[0] = gpio_assign(1, 19, GPIO_DIR_INPUT, false);
HARDBTN[1] = gpio_assign(1, 16, GPIO_DIR_INPUT, false);
HARDBTN[2] = gpio_assign(1, 17, GPIO_DIR_INPUT, false);
HARDBTN[3] = gpio_assign(0, 7, GPIO_DIR_INPUT, false);
//HARDBTN[4] = gpio_assign(1, 3, GPIO_DIR_INPUT, false);
/*-----------------------------------------------------*/
ScreenBuff = new_(new_screen);
ScreenBuff->raster_timings = &HDMI_DISPLAY_MODE_STRUCT;
ScreenBuff->BackLightPort = 1;
ScreenBuff->BackLightPin = 18;
screen_init(ScreenBuff);
#ifdef touch
TouchScreen->screen_max_x = ScreenBuff->raster_timings->X;
TouchScreen->screen_max_y = ScreenBuff->raster_timings->Y;
TouchScreen->pDisplay = ScreenBuff;
InitTouchScreen(TouchScreen);
UARTPuts(DebugCom, "Init calibration of LCD resistive touch screen....." , -1);
TouchCalibrate(TouchScreen, ScreenBuff);
UARTPuts(DebugCom, "OK.\n\r" , -1);
#endif
UARTprintf(DebugCom, "LCD display initialize successful for %dx%d resolution, %d Bit bus.\n\r" , ScreenBuff->raster_timings->X, ScreenBuff->raster_timings->Y, ScreenBuff->raster_timings->bus_size);
put_rectangle(ScreenBuff, 0, 0, ScreenBuff->raster_timings->X, ScreenBuff->raster_timings->Y, true, controls_color.Scren);
box_cache_clean(ScreenBuff, 0, 0, ScreenBuff->raster_timings->X, ScreenBuff->raster_timings->Y);
backlight_on(ScreenBuff);
}
#endif
}
return true;
}
static int init_dircache(bool preinit)
{
#ifdef HAVE_DIRCACHE
int result = 0;
bool clear = false;
if (preinit)
dircache_init();
if (!global_settings.dircache)
return 0;
# ifdef HAVE_EEPROM_SETTINGS
if (firmware_settings.initialized && firmware_settings.disk_clean
&& preinit)
{
result = dircache_load();
if (result < 0)
{
firmware_settings.disk_clean = false;
if (global_status.dircache_size <= 0)
{
/* This will be in default language, settings are not
applied yet. Not really any easy way to fix that. */
splash(0, str(LANG_SCANNING_DISK));
clear = true;
}
dircache_build(global_status.dircache_size);
}
}
else
# endif
{
if (preinit)
return -1;
if (!dircache_is_enabled()
&& !dircache_is_initializing())
{
if (global_status.dircache_size <= 0)
{
splash(0, str(LANG_SCANNING_DISK));
clear = true;
}
result = dircache_build(global_status.dircache_size);
}
if (result < 0)
{
/* Initialization of dircache failed. Manual action is
* necessary to enable dircache again.
*/
splashf(0, "Dircache failed, disabled. Result: %d", result);
global_settings.dircache = false;
}
}
if (clear)
{
backlight_on();
show_logo();
global_status.dircache_size = dircache_get_cache_size();
status_save();
}
return result;
#else
(void)preinit;
return 0;
#endif
}
bool search_playlist(void)
{
char search_str[32] = "";
bool ret = false, exit = false;
int i, playlist_count;
int found_indicies[MAX_PLAYLIST_ENTRIES];
int found_indicies_count = 0, last_found_count = -1;
int button;
struct gui_synclist playlist_lists;
struct playlist_track_info track;
if (!playlist_viewer_init(&viewer, 0, false))
return ret;
if (kbd_input(search_str, sizeof(search_str)) < 0)
return ret;
lcd_clear_display();
playlist_count = playlist_amount_ex(viewer.playlist);
cpu_boost(true);
for (i = 0; i < playlist_count &&
found_indicies_count < MAX_PLAYLIST_ENTRIES; i++)
{
if (found_indicies_count != last_found_count)
{
splashf(0, str(LANG_PLAYLIST_SEARCH_MSG), found_indicies_count,
str(LANG_OFF_ABORT));
last_found_count = found_indicies_count;
}
if (action_userabort(TIMEOUT_NOBLOCK))
break;
playlist_get_track_info(viewer.playlist, i, &track);
if (strcasestr(track.filename,search_str))
found_indicies[found_indicies_count++] = track.index;
yield();
}
cpu_boost(false);
if (!found_indicies_count)
{
return ret;
}
backlight_on();
gui_synclist_init(&playlist_lists, playlist_search_callback_name,
found_indicies, false, 1, NULL);
gui_synclist_set_title(&playlist_lists, str(LANG_SEARCH_RESULTS), NOICON);
gui_synclist_set_icon_callback(&playlist_lists, NULL);
gui_synclist_set_nb_items(&playlist_lists, found_indicies_count);
gui_synclist_select_item(&playlist_lists, 0);
gui_synclist_draw(&playlist_lists);
while (!exit)
{
if (list_do_action(CONTEXT_LIST, HZ/4,
&playlist_lists, &button, LIST_WRAP_UNLESS_HELD))
continue;
switch (button)
{
case ACTION_STD_CANCEL:
exit = true;
break;
case ACTION_STD_OK:
{
int sel = gui_synclist_get_sel_pos(&playlist_lists);
playlist_start(found_indicies[sel], 0);
exit = 1;
}
break;
default:
if (default_event_handler(button) == SYS_USB_CONNECTED)
{
ret = true;
exit = true;
}
break;
}
}
return ret;
}
static void button_tick(void)
{
static int count = 0;
static int repeat_speed = REPEAT_INTERVAL_START;
static int repeat_count = 0;
static bool repeat = false;
static bool post = false;
#ifdef HAVE_BACKLIGHT
static bool skip_release = false;
#ifdef HAVE_REMOTE_LCD
static bool skip_remote_release = false;
#endif
#endif
int diff;
int btn;
#ifdef HAVE_BUTTON_DATA
int data = 0;
#else
const int data = 0;
#endif
#if defined(HAS_SERIAL_REMOTE) && !defined(SIMULATOR)
/* Post events for the remote control */
btn = remote_control_rx();
if(btn)
button_try_post(btn, 0);
#endif
#ifdef HAVE_BUTTON_DATA
btn = button_read(&data);
#else
btn = button_read();
#endif
#if defined(HAVE_HEADPHONE_DETECTION)
if (headphones_inserted() != phones_present)
{
/* Use the autoresetting oneshot to debounce the detection signal */
phones_present = !phones_present;
timeout_register(&hp_detect_timeout, btn_detect_callback,
HZ/2, phones_present);
}
#endif
/* Find out if a key has been released */
diff = btn ^ lastbtn;
if(diff && (btn & diff) == 0)
{
#ifdef HAVE_BACKLIGHT
#ifdef HAVE_REMOTE_LCD
if(diff & BUTTON_REMOTE)
if(!skip_remote_release)
button_try_post(BUTTON_REL | diff, data);
else
skip_remote_release = false;
else
#endif
if(!skip_release)
button_try_post(BUTTON_REL | diff, data);
else
skip_release = false;
#else
button_try_post(BUTTON_REL | diff, data);
#endif
}
else
{
if ( btn )
{
/* normal keypress */
if ( btn != lastbtn )
{
post = true;
repeat = false;
repeat_speed = REPEAT_INTERVAL_START;
}
else /* repeat? */
{
if ( repeat )
{
if (!post)
count--;
if (count == 0) {
post = true;
/* yes we have repeat */
if (repeat_speed > REPEAT_INTERVAL_FINISH)
repeat_speed--;
count = repeat_speed;
repeat_count++;
/* Send a SYS_POWEROFF event if we have a device
which doesn't shut down easily with the OFF
key */
#ifdef HAVE_SW_POWEROFF
if ((btn & POWEROFF_BUTTON
#ifdef RC_POWEROFF_BUTTON
|| btn == RC_POWEROFF_BUTTON
#endif
) &&
#if CONFIG_CHARGING && !defined(HAVE_POWEROFF_WHILE_CHARGING)
!charger_inserted() &&
#endif
repeat_count > POWEROFF_COUNT)
{
/* Tell the main thread that it's time to
power off */
sys_poweroff();
/* Safety net for players without hardware
poweroff */
#if (CONFIG_PLATFORM & PLATFORM_NATIVE)
if(repeat_count > POWEROFF_COUNT * 10)
power_off();
#endif
}
#endif
}
}
else
{
if (count++ > REPEAT_START)
{
post = true;
repeat = true;
repeat_count = 0;
/* initial repeat */
count = REPEAT_INTERVAL_START;
}
#ifdef HAVE_TOUCHSCREEN
else if (lastdata != data && btn == lastbtn)
{ /* only coordinates changed, post anyway */
if (touchscreen_get_mode() == TOUCHSCREEN_POINT)
post = true;
}
#endif
}
}
if ( post )
{
if (repeat)
{
/* Only post repeat events if the queue is empty,
* to avoid afterscroll effects. */
if (button_try_post(BUTTON_REPEAT | btn, data))
{
#ifdef HAVE_BACKLIGHT
#ifdef HAVE_REMOTE_LCD
skip_remote_release = false;
#endif
skip_release = false;
#endif
post = false;
}
}
else
{
#ifdef HAVE_BACKLIGHT
#ifdef HAVE_REMOTE_LCD
if (btn & BUTTON_REMOTE) {
if (!remote_filter_first_keypress
|| is_remote_backlight_on(false)
#if defined(IRIVER_H100_SERIES) || defined(IRIVER_H300_SERIES)
|| (remote_type()==REMOTETYPE_H300_NONLCD)
#endif
)
button_try_post(btn, data);
else
skip_remote_release = true;
}
else
#endif
if (!filter_first_keypress || is_backlight_on(false)
#if BUTTON_REMOTE
|| (btn & BUTTON_REMOTE)
#endif
)
button_try_post(btn, data);
else
skip_release = true;
#else /* no backlight, nothing to skip */
button_try_post(btn, data);
#endif
post = false;
}
#ifdef HAVE_REMOTE_LCD
if(btn & BUTTON_REMOTE)
remote_backlight_on();
else
#endif
{
backlight_on();
#ifdef HAVE_BUTTON_LIGHT
buttonlight_on();
#endif
}
reset_poweroff_timer();
}
}
else
{
repeat = false;
count = 0;
}
}
lastbtn = btn & ~(BUTTON_REL | BUTTON_REPEAT);
#ifdef HAVE_BUTTON_DATA
lastdata = data;
#endif
}
bool main_hid_generic_enable(void)
{
main_b_generic_enable = true;
backlight_on();
return true;
}
void menu_global_setup(void) {
u8 item = 0;
u8 item_val = 0; // now selecting item
global_setup_t func = gs_config[item];
// cleanup screen and disable possible low bat warning
buzzer_off();
key_beep();
menu_battery_low = 0; // it will be set automatically again
backlight_set_default(BACKLIGHT_MAX);
backlight_on();
lcd_clear();
lcd_segment(LS_MENU_MODEL, LS_ON);
lcd_segment_blink(LS_MENU_MODEL, LB_INV);
lcd_segment_blink(LS_MENU_NAME, LB_INV);
lcd_update();
func(0); // show current value
while (1) {
btnra();
stop();
if (btnl(BTN_BACK | BTN_ENTER)) break;
if (btn(BTN_ENTER)) {
if (item > 0) { // not for firmware version
key_beep();
item_val = (u8)(1 - item_val);
if (item_val) {
// changing value
lcd_chars_blink(LB_SPC);
}
else {
// selecting item
lcd_chars_blink(LB_OFF);
}
}
}
else if (btn(BTN_ROT_ALL)) {
if (item_val) {
// change item value
func(1);
lcd_chars_blink(LB_SPC);
}
else {
// select another item
func(0xff); // un-show labels
if (btn(BTN_ROT_L)) {
if (item) item--;
else item = GS_CONFIG_SIZE - 1;
}
else {
if (++item >= GS_CONFIG_SIZE) item = 0;
}
func = gs_config[item];
func(0); // show current value
}
lcd_update();
}
}
func(0xff); // un-show labels, apply resets
beep(60);
lcd_clear();
config_global_save();
apply_global_config();
}
// read all keys
static void read_keys(void) {
u16 buttons_state_last = buttons_state;
u16 buttons_last = buttons;
u16 bit;
u8 i, lbs, bs;
// rotate last buttons
buttons3 = buttons2;
buttons2 = buttons1;
// read actual keys status
buttons1 = read_key_matrix();
// add CH3 button
if (adc_ch3_last < 50) buttons1 |= BTN_CH3;
// combine last 3 readed buttons
buttons_state |= buttons1 & buttons2 & buttons3;
buttons_state &= buttons1 | buttons2 | buttons3;
// do autorepeat/long_press only when some keys were pressed
if (buttons_state_last || buttons_state) {
// key pressed or released, activate backlight
backlight_on();
// handle autorepeat for first 8 keys (TRIMs and D/R)
if (buttons_autorepeat) {
for (i = 0, bit = 1; i < 8; i++, bit <<= 1) {
if (!(bit & buttons_autorepeat)) continue; // not autorepeated
lbs = (u8)(buttons_state_last & bit ? 1 : 0);
bs = (u8)(buttons_state & bit ? 1 : 0);
if (!lbs) {
// last not pressed
if (bs) {
// now pressed, set it pressed and set autorepeat delay
buttons |= bit;
buttons_timer[i] = BTN_AUTOREPEAT_DELAY;
}
// do nothing for now not pressed
}
else {
// last was pressed
if (bs) {
// now pressed
if (--buttons_timer[i]) continue; // not expired yet
// timer expired, set it pressed and set autorepeat rate
buttons |= bit;
buttons_timer[i] = BTN_AUTOREPEAT_RATE;
}
// do nothing for now not pressed
}
}
}
// handle long presses for first 12 keys
// exclude keys with autorepeat ON
for (i = 0, bit = 1; i < 12; i++, bit <<= 1) {
if (bit & buttons_autorepeat) continue; // handled in autorepeat
lbs = (u8)(buttons_state_last & bit ? 1 : 0);
bs = (u8)(buttons_state & bit ? 1 : 0);
if (!lbs) {
// last not pressed
if (bs) {
// now pressed, set long press delay
buttons_timer[i] = cg.long_press_delay;
}
// do nothing for now not pressed
}
else {
// last was pressed
if (bs) {
// now pressed, check long press delay
// if already long or not long enought, skip
if (!buttons_timer[i] || --buttons_timer[i]) continue;
// set as pressed and long pressed
buttons |= bit;
buttons_long |= bit;
}
else {
// now not pressed, set as pressed when no long press was applied
if (!buttons_timer[i]) continue; // was long before
buttons |= bit;
}
}
}
}
// add rotate encoder
if (encoder_timer) encoder_timer--;
if (TIM1_CNTRL) {
// encoder changed
if ((s8)TIM1_CNTRL >= 0) {
// left
buttons |= BTN_ROT_L;
if (encoder_timer) buttons_long |= BTN_ROT_L;
}
else {
// right
buttons |= BTN_ROT_R;
if (encoder_timer) buttons_long |= BTN_ROT_R;
}
// set it back to default value
TIM1_CNTRL = 0;
// init timer
encoder_timer = ENCODER_FAST_THRESHOLD;
backlight_on();
}
// if some of the keys changed, wakeup MENU task and reset inactivity timer
if (buttons_last != buttons || buttons_state_last != buttons_state) {
awake(MENU);
reset_inactivity_timer();
}
}
