lmh188
/
newtx
mirror of http://192.168.1.51:8099/scanner/newtx.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

优化扫描流程以匹配待纸扫描；历史及滚轴张数增加各速度模式下的耗时毫秒数

This commit is contained in:
gb 2024-02-07 16:26:23 +08:00
parent d35cea52c5
commit 13eaabd931
6 changed files with 400 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
hardware/hardware.cpp
View File

@ -32,7 +32,7 @@ static std::string device_opt_json[] = {
scanner_hw::scanner_hw() : mb_events_("motorboard-event")
{
set_where("hardware");
// mb_events_.enable_wait_log(false);
mb_events_.enable_wait_log(false);
memset(&img_base_, 0, sizeof(img_base_));
img_base_.bpp = 8;
img_base_.bppc = 8;
@ -348,13 +348,13 @@ void scanner_hw::init_version(std::string& text)
}
jsn->release();
}
void scanner_hw::thread_image_capture(void)
void scanner_hw::thread_image_capture(bool paper_ready)
{
PACKIMAGE img(img_base_);
safe_fifo<int> avail_mem("v4l2-mem");
int used_v4l2_mem = 0, times = 0, minh = 210 * dpi_ / 25.4,
err = SCANNER_ERR_OK;
uint8_t scanmode = count_mode_ ? devui::SCAN_COUNT_MODE : devui::SCAN_NORMAL;
devui::SCANSTREAM scanstream;
chronograph watch;
std::pair<int, int> mbev;
std::function<IMAGE_HANDLER_PROTO> img_callback(img_handler_);
@ -369,9 +369,15 @@ void scanner_hw::thread_image_capture(void)
utils::to_log(LOG_LEVEL_DEBUG, "scanning thread working ...\n");
motor_->clear_error();
if(paper_ready)
motor_->start();
// to_lifter_ = 0;
while(scanning_ && times++ < 5)
scanstream.mode = count_mode_ ? devui::SCAN_COUNT_MODE : devui::SCAN_NORMAL;
scanstream.speed = sp_;
devui::send_message(devui::UI_STATUS_SCANNING, (uint8_t*)&scanstream, sizeof(scanstream));
while(scanning_) // auto scan cycle ...
{
int attempt = 0;
while(paper_ready && scanning_ && attempt++ < 5)
{
if(mb_events_.take(mbev, true, to_lifter_)
&& mbev.first == MOTOR_BORD_EVENT_LIFTER_READY)
@ -383,9 +389,7 @@ void scanner_hw::thread_image_capture(void)
utils::to_log(LOG_LEVEL_FATAL, "Wait Lifter event(%d - 0x%08x) before scanning failed.\n", mbev.first, mbev.second);
motor_->start();
}
times = 0;
devui::send_message(devui::UI_STATUS_SCANNING, &scanmode, sizeof(scanmode));
while(scanning_ && mbev.first == MOTOR_BORD_EVENT_LIFTER_READY) // auto scan cycle ...
if(mbev.first == MOTOR_BORD_EVENT_LIFTER_READY)
{
times++;
watch.reset();
@ -394,6 +398,7 @@ void scanner_hw::thread_image_capture(void)
// scanning ONE turn ...
while(scanning_ && motor_->wait_paper_out(to_paper_out_))
{
uint32_t pass = watch.elapse_ms();
if(mb_events_.take(mbev) && mbev.first == MOTOR_BORD_EVENT_ERROR)
{
err = trans_motorboard_err_2_hg_error(mbev.second);
@ -410,7 +415,7 @@ void scanner_hw::thread_image_capture(void)
}
img.pos.paper_ind++;
devui::send_message(devui::UI_STATUS_PAPER_CNT, nullptr, 0);
devui::send_message(devui::UI_STATUS_PAPER_CNT, (uint8_t*)&pass, sizeof(pass));
if(!count_mode_)
{
@ -459,6 +464,7 @@ void scanner_hw::thread_image_capture(void)
used_v4l2_mem--;
camera_->add_v4l2_memory(ind);
}
}
{
uint8_t scan = devui::SCAN_PAUSED;
@ -781,7 +787,6 @@ int scanner_hw::open(std::function<IMAGE_HANDLER_PROTO> image_handler, std::stri
auto cb = [this](int ev, unsigned int data) -> void
{
printf("MBEV: %d-%x\n", ev, data);
mb_events_.save(std::make_pair(ev, data), true);
};
mb_events_.clear();
@ -880,12 +885,13 @@ int scanner_hw::start_scan(void)
((SMBMODE*)&val)->paper_jammed_out)
return DEV_ERR(PAPER_JAMMED);
if(((SMBMODE*)&val)->feeding_paper_ready == 0 && !auto_scan_)
bool paperok = ((SMBMODE*)&val)->feeding_paper_ready;
if(!paperok && !auto_scan_)
return DEV_ERR(NO_PAPER);
scanning_ = true;
mb_events_.clear();
scan_thread_.reset(new std::thread(&scanner_hw::thread_image_capture, this));
scan_thread_.reset(new std::thread(&scanner_hw::thread_image_capture, this, paperok));
return SCANNER_ERR_OK;
}

2
hardware/hardware.h
View File

@ -99,7 +99,7 @@ class scanner_hw : public sane_opt_provider
void init(void);
void init_version(std::string& text);
void thread_image_capture(void);
void thread_image_capture(bool paper_ready);
int get_image_real_height(int minh);
bool is_scan_fatal(void);
void retrieve_v4l2_mem(safe_fifo<int>* mem, int* used);

9
sdk/base/ui.h
View File

@ -23,8 +23,8 @@ namespace devui
UI_CMD_COUNT_PAPER = 0x10,
UI_CMD_STOP_SCAN,
UI_STATUS_SCANNING = 0x1000, // begin scanning. data: (enum scan)
UI_STATUS_PAPER_CNT, // ONE paper has pass through. data: none
UI_STATUS_SCANNING = 0x1000, // begin scanning. data: (LPSCANSTREAM)
UI_STATUS_PAPER_CNT, // ONE paper has pass through. data: (uint32_t*)milliseconds for paper pass through
};
#pragma pack(push)
@ -44,6 +44,11 @@ namespace devui
return sizeof(*this);
}
}MSGSTREAM, *LPMSGSTREAM;
typedef struct _scan_stream
{
uint8_t mode; // see enum scan
uint32_t speed;
}SCANSTREAM, *LPSCANSTREAM;
#pragma pack(pop)
void init_ui(std::function<void(LPMSGSTREAM)> uicb, bool ui);

217
ui/dev_menu.cpp
View File

@ -210,8 +210,10 @@ int dev_menu::get_menu_text(std::vector<std::string>& text, int& sel)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ui_mgr
enum
namespace menu_command
{
enum
{
MENU_CMD_ID_CANCEL = 0,
MENU_CMD_ID_SEPARATE_LOW = 0x10,
@ -243,6 +245,40 @@ enum
MENU_CMD_ID_SHUTDOWN = 0x90,
MENU_CMD_ID_WELCOME = 0xa0,
};
static std::string command_string(int cmd)
{
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_CANCEL);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_SEPARATE_LOW);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_SEPARATE_MID);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_SEPARATE_HIGH);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_SLEEP_NEVER);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_SLEEP_IMMEDIATELY);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_SLEEP_5MIN);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_SLEEP_10MIN);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_SLEEP_20MIN);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_SLEEP_30MIN);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_SLEEP_1H);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_SLEEP_2H);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_SLEEP_4H);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_LIFTER_LOW);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_LIFTER_MID);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_LIFTER_HIGH);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_COUNT_MODE);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_HANDLE_MODE);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_CLEAR_PASSWAY);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_GET_HISTORY_COUNT);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_CLEAR_ROLLER_CNT);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_GET_ROLLER_COUNT);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_SHUTDOWN);
RETURN_ENUM_STR(cmd, menu_command::MENU_CMD_ID_WELCOME);
char unk[40] = {0};
sprintf(unk, "Unknown menu command: %d", cmd);
return unk;
}
};
namespace welcome
{
@ -350,9 +386,15 @@ static uint8_t qiaoting[] = {128, 32
};
static uint8_t* pics[] = {ddjx, mugui, qiaoting};
static int index_ = 0;
static int index_ = -1;
static uint8_t* get_current_pic(void)
{
if(index_ == -1)
{
srand(time(nullptr));
index_ = rand() % _countof(pics);
}
uint8_t* cur = pics[index_++];
index_ %= _countof(pics);
@ -363,6 +405,10 @@ static uint8_t qiaoting[] = {128, 32
ui_mgr::ui_mgr() : disp_data_("lcd-msg")
{
utils::init_log(LOG_TYPE_FILE);
perm_data_.reset(new permanent_data());
disp_data_.enable_wait_log(false);
init();
auto ke = [this](int key) -> MENU_CMD_HANDLER_RET
@ -373,10 +419,6 @@ ui_mgr::ui_mgr() : disp_data_("lcd-msg")
lcd_->Lcd_Initial_Lcd(false);
lcd_->clear();
srand(time(nullptr));
his_cnt_ = rand() % 1000000;
rol_cnt_ = his_cnt_ / (2 + (rand() % 5));
ready_.cnt = custom_font::get_string_font(WORDS_STATUS_READY, ready_.ptr);
ready_.x = (Lcd::LCD_WIDTH - ready_.ptr[0][0] * ready_.cnt) / 2;
ready_.y = (Lcd::LCD_HEIGHT - ready_.ptr[0][1]) / 2;
@ -394,15 +436,21 @@ ui_mgr::ui_mgr() : disp_data_("lcd-msg")
{
if(pack->msg == devui::UI_STATUS_SCANNING)
{
scanning_ = pack->data[0] != devui::SCAN_STOPPED;
devui::LPSCANSTREAM scan = (devui::LPSCANSTREAM)pack->data;
scanning_ = scan->mode != devui::SCAN_STOPPED;
set_ready_status_enabled(!scanning_);
if(scanning_)
{
paper_cnt_ = 0;
if(pack->data[0] != devui::SCAN_PAUSED)
if(pack->data[0] == devui::SCAN_PAUSED)
{
perm_data_->save();
}
else
{
DISPDATA dd;
perm_data_->set_speed(scan->speed);
paper_total_ = 0;
memset(&dd, 0, sizeof(dd));
dd.cnt = dd.mask = -1;
@ -423,6 +471,7 @@ ui_mgr::ui_mgr() : disp_data_("lcd-msg")
paper_cnt_++;
paper_total_++;
perm_data_->increase_count(*(uint32_t*)pack->data);
sprintf(num, "%03d", paper_cnt_);
dd.x = hold_pos_.x;
dd.y = hold_pos_.y;
@ -448,12 +497,17 @@ ui_mgr::~ui_mgr()
devui::uninit_ui();
clear();
perm_data_.reset(nullptr);
utils::uninit();
}
bool ui_mgr::do_menu_command(int cmd)
{
bool holdui = false;
utils::to_log(LOG_LEVEL_DEBUG, "Do menu command: %s\n", menu_command::command_string(cmd).c_str());
if(handler_.count(cmd))
holdui = handler_[cmd](cur_, cmd);
@ -478,29 +532,29 @@ void ui_mgr::init(void)
// 分纸强度（低中高）
{
child = new dev_menu(true);
child->add_menu(WORDS_MENU_LOW, MENU_CMD_ID_SEPARATE_LOW);
child->add_menu(WORDS_MENU_LOW, menu_command::MENU_CMD_ID_SEPARATE_LOW);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_SEPARATE_LOW] = f;
handler_[menu_command::MENU_CMD_ID_SEPARATE_LOW] = f;
}
child->add_menu(WORDS_MENU_MID, MENU_CMD_ID_SEPARATE_MID);
child->add_menu(WORDS_MENU_MID, menu_command::MENU_CMD_ID_SEPARATE_MID);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_SEPARATE_MID] = f;
handler_[menu_command::MENU_CMD_ID_SEPARATE_MID] = f;
}
child->add_menu(WORDS_MENU_HIGH, MENU_CMD_ID_SEPARATE_HIGH);
child->add_menu(WORDS_MENU_HIGH, menu_command::MENU_CMD_ID_SEPARATE_HIGH);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_SEPARATE_HIGH] = f;
handler_[menu_command::MENU_CMD_ID_SEPARATE_HIGH] = f;
}
child->select(WORDS_MENU_MID);
root_->add_menu(WORDS_MENU_SEPARATE_STRENGTH, child);
@ -509,77 +563,77 @@ void ui_mgr::init(void)
// 休眠时间（不休眠，5min, 10min, 20min, 30min, 1h, 2h, 4h）
{
child = new dev_menu(true);
child->add_menu(WORDS_MENU_SLEEP_NONE, MENU_CMD_ID_SLEEP_NEVER);
child->add_menu(WORDS_MENU_SLEEP_NONE, menu_command::MENU_CMD_ID_SLEEP_NEVER);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_SLEEP_NEVER] = f;
handler_[menu_command::MENU_CMD_ID_SLEEP_NEVER] = f;
}
child->add_menu(WORDS_MENU_SLEEP_NOW, MENU_CMD_ID_SLEEP_IMMEDIATELY);
child->add_menu(WORDS_MENU_SLEEP_NOW, menu_command::MENU_CMD_ID_SLEEP_IMMEDIATELY);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_SLEEP_IMMEDIATELY] = f;
handler_[menu_command::MENU_CMD_ID_SLEEP_IMMEDIATELY] = f;
}
child->add_menu(WORDS_MENU_SLEEP_5_MIN, MENU_CMD_ID_SLEEP_5MIN);
child->add_menu(WORDS_MENU_SLEEP_5_MIN, menu_command::MENU_CMD_ID_SLEEP_5MIN);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_SLEEP_5MIN] = f;
handler_[menu_command::MENU_CMD_ID_SLEEP_5MIN] = f;
}
child->add_menu(WORDS_MENU_SLEEP_10_MIN, MENU_CMD_ID_SLEEP_10MIN);
child->add_menu(WORDS_MENU_SLEEP_10_MIN, menu_command::MENU_CMD_ID_SLEEP_10MIN);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_SLEEP_10MIN] = f;
handler_[menu_command::MENU_CMD_ID_SLEEP_10MIN] = f;
}
child->add_menu(WORDS_MENU_SLEEP_20_MIN, MENU_CMD_ID_SLEEP_20MIN);
child->add_menu(WORDS_MENU_SLEEP_20_MIN, menu_command::MENU_CMD_ID_SLEEP_20MIN);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_SLEEP_20MIN] = f;
handler_[menu_command::MENU_CMD_ID_SLEEP_20MIN] = f;
}
child->add_menu(WORDS_MENU_SLEEP_30_MIN, MENU_CMD_ID_SLEEP_30MIN);
child->add_menu(WORDS_MENU_SLEEP_30_MIN, menu_command::MENU_CMD_ID_SLEEP_30MIN);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_SLEEP_30MIN] = f;
handler_[menu_command::MENU_CMD_ID_SLEEP_30MIN] = f;
}
child->add_menu(WORDS_MENU_SLEEP_1_HOUR, MENU_CMD_ID_SLEEP_1H);
child->add_menu(WORDS_MENU_SLEEP_1_HOUR, menu_command::MENU_CMD_ID_SLEEP_1H);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_SLEEP_1H] = f;
handler_[menu_command::MENU_CMD_ID_SLEEP_1H] = f;
}
child->add_menu(WORDS_MENU_SLEEP_2_HOUR, MENU_CMD_ID_SLEEP_2H);
child->add_menu(WORDS_MENU_SLEEP_2_HOUR, menu_command::MENU_CMD_ID_SLEEP_2H);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_SLEEP_2H] = f;
handler_[menu_command::MENU_CMD_ID_SLEEP_2H] = f;
}
child->add_menu(WORDS_MENU_SLEEP_4_HOUR, MENU_CMD_ID_SLEEP_4H);
child->add_menu(WORDS_MENU_SLEEP_4_HOUR, menu_command::MENU_CMD_ID_SLEEP_4H);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_SLEEP_4H] = f;
handler_[menu_command::MENU_CMD_ID_SLEEP_4H] = f;
}
child->select(WORDS_MENU_SLEEP_NONE);
root_->add_menu(WORDS_MENU_POWER, child);
@ -587,7 +641,7 @@ void ui_mgr::init(void)
}
// 计数模式、手动模式、清理纸道、历史张数、滚轴张数、清除滚轴张数(确定，取消)、进入休眠、关机
root_->add_menu(WORDS_MENU_COUNT_MODE, MENU_CMD_ID_COUNT_MODE);
root_->add_menu(WORDS_MENU_COUNT_MODE, menu_command::MENU_CMD_ID_COUNT_MODE);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
@ -615,40 +669,33 @@ void ui_mgr::init(void)
hold_pos_.x += 2;
disp_data_.save(dd, true);
// auto test = [this](void) -> void
// {
// thread_test_hold_ui();
// };
// disp_thrd_.stop("thread_test_hold_ui");
// disp_thrd_.start(test, "thread_test_hold_ui");
devui::send_message(devui::UI_CMD_COUNT_PAPER);
return true;
};
handler_[MENU_CMD_ID_COUNT_MODE] = f;
handler_[menu_command::MENU_CMD_ID_COUNT_MODE] = f;
}
root_->add_menu(WORDS_MENU_MANUAL_MODE, MENU_CMD_ID_HANDLE_MODE);
root_->add_menu(WORDS_MENU_MANUAL_MODE, menu_command::MENU_CMD_ID_HANDLE_MODE);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return true;
};
handler_[MENU_CMD_ID_HANDLE_MODE] = f;
handler_[menu_command::MENU_CMD_ID_HANDLE_MODE] = f;
}
root_->add_menu(WORDS_MENU_CLEAR_PASSWAY, MENU_CMD_ID_CLEAR_PASSWAY);
root_->add_menu(WORDS_MENU_CLEAR_PASSWAY, menu_command::MENU_CMD_ID_CLEAR_PASSWAY);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_CLEAR_PASSWAY] = f;
handler_[menu_command::MENU_CMD_ID_CLEAR_PASSWAY] = f;
}
root_->add_menu(WORDS_MENU_HISTORY_COUNT, MENU_CMD_ID_GET_HISTORY_COUNT);
root_->add_menu(WORDS_MENU_HISTORY_COUNT, menu_command::MENU_CMD_ID_GET_HISTORY_COUNT);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
DISPDATA dd;
char cnt[40] = {0};
memset(&dd, 0, sizeof(dd));
dd.cnt = dd.mask = -1;
@ -660,15 +707,14 @@ void ui_mgr::init(void)
dd.y = dd.ptr[0][1];
dd.x = dd.ptr[0][0] * 2;
sprintf(cnt, "%u", his_cnt_);
dd.cnt = custom_font::get_string_font(cnt, dd.ptr);
dd.cnt = custom_font::get_string_font(std::to_string(perm_data_->history_count()).c_str(), dd.ptr);
disp_data_.save(dd, true);
return true;
};
handler_[MENU_CMD_ID_GET_HISTORY_COUNT] = f;
handler_[menu_command::MENU_CMD_ID_GET_HISTORY_COUNT] = f;
}
root_->add_menu(WORDS_MENU_ROLLER_COUNT, MENU_CMD_ID_GET_ROLLER_COUNT);
root_->add_menu(WORDS_MENU_ROLLER_COUNT, menu_command::MENU_CMD_ID_GET_ROLLER_COUNT);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
@ -685,56 +731,56 @@ void ui_mgr::init(void)
dd.y = dd.ptr[0][1];
dd.x = dd.ptr[0][0] * 2;
sprintf(cnt, "%u", rol_cnt_);
sprintf(cnt, "%u", perm_data_->roller_count());
dd.cnt = custom_font::get_string_font(cnt, dd.ptr);
disp_data_.save(dd, true);
return true;
};
handler_[MENU_CMD_ID_GET_ROLLER_COUNT] = f;
handler_[menu_command::MENU_CMD_ID_GET_ROLLER_COUNT] = f;
}
{
child = new dev_menu(false, false);
child->add_menu(WORDS_MENU_YES, MENU_CMD_ID_CLEAR_ROLLER_CNT);
child->add_menu(WORDS_MENU_YES, menu_command::MENU_CMD_ID_CLEAR_ROLLER_CNT);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
rol_cnt_ = 0;
perm_data_->clear_roller_count();
return false;
};
handler_[MENU_CMD_ID_CLEAR_ROLLER_CNT] = f;
handler_[menu_command::MENU_CMD_ID_CLEAR_ROLLER_CNT] = f;
}
child->add_menu(WORDS_MENU_NO, MENU_CMD_ID_CANCEL);
child->add_menu(WORDS_MENU_NO, menu_command::MENU_CMD_ID_CANCEL);
root_->add_menu(WORDS_MENU_RESET_ROLLOER_CNT, child);
child->release();
}
// 升降台位置（低中高）
{
child = new dev_menu(true);
child->add_menu(WORDS_MENU_LOW, MENU_CMD_ID_LIFTER_LOW);
child->add_menu(WORDS_MENU_LOW, menu_command::MENU_CMD_ID_LIFTER_LOW);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_LIFTER_LOW] = f;
handler_[menu_command::MENU_CMD_ID_LIFTER_LOW] = f;
}
child->add_menu(WORDS_MENU_MID, MENU_CMD_ID_LIFTER_MID);
child->add_menu(WORDS_MENU_MID, menu_command::MENU_CMD_ID_LIFTER_MID);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_LIFTER_MID] = f;
handler_[menu_command::MENU_CMD_ID_LIFTER_MID] = f;
}
child->add_menu(WORDS_MENU_HIGH, MENU_CMD_ID_LIFTER_HIGH);
child->add_menu(WORDS_MENU_HIGH, menu_command::MENU_CMD_ID_LIFTER_HIGH);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
return false;
};
handler_[MENU_CMD_ID_LIFTER_HIGH] = f;
handler_[menu_command::MENU_CMD_ID_LIFTER_HIGH] = f;
}
child->select(WORDS_MENU_LOW);
root_->add_menu(WORDS_MENU_LIFTER_POS, child);
@ -742,7 +788,7 @@ void ui_mgr::init(void)
}
{
child = new dev_menu(false, false);
child->add_menu(WORDS_MENU_YES, MENU_CMD_ID_SHUTDOWN);
child->add_menu(WORDS_MENU_YES, menu_command::MENU_CMD_ID_SHUTDOWN);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
@ -750,14 +796,14 @@ void ui_mgr::init(void)
return false;
};
handler_[MENU_CMD_ID_SHUTDOWN] = f;
handler_[menu_command::MENU_CMD_ID_SHUTDOWN] = f;
}
child->add_menu(WORDS_MENU_NO, MENU_CMD_ID_CANCEL);
child->add_menu(WORDS_MENU_NO, menu_command::MENU_CMD_ID_CANCEL);
root_->add_menu(WORDS_MENU_SHUTDOWN, child);
child->release();
}
root_->add_menu(WORDS_MENU_WELCOME, MENU_CMD_ID_WELCOME);
root_->add_menu(WORDS_MENU_WELCOME, menu_command::MENU_CMD_ID_WELCOME);
{
auto f = [this](dev_menu* m, int id) -> MENU_CMD_HANDLER_RET
{
@ -771,7 +817,7 @@ void ui_mgr::init(void)
return false;
};
handler_[MENU_CMD_ID_WELCOME] = f;
handler_[menu_command::MENU_CMD_ID_WELCOME] = f;
}
cur_ = root_;
@ -864,41 +910,6 @@ void ui_mgr::enter(void)
}
}
void ui_mgr::thread_test_hold_ui(void)
{
uint32_t cnt = 99900 + (rand() % 100);
DISPDATA dd;
char number[40] = {0};
custom_font::font_size size = custom_font::FONT_SIZE_16;
dd.x = hold_pos_.x;
dd.y = hold_pos_.y;
dd.mask = 0;
printf("Start testing count from %d\n", cnt);
while(!menu_mode_)
{
rol_cnt_++;
his_cnt_++;
sprintf(number, "%d", cnt++);
if(size == custom_font::FONT_SIZE_16 && (Lcd::LCD_WIDTH - dd.x) / font_size_.cx < strlen(number))
{
{
// clear
dd.cnt = -1;
dd.mask = -1;
dd.ptr[0] = nullptr; // perform clear
disp_data_.save(dd, true);
dd.mask = 0;
}
size = custom_font::FONT_SIZE_8;
dd.y += Lcd::LCD_LINE_PER_PAGE;
}
dd.cnt = custom_font::get_string_font(number, dd.ptr, size);
disp_data_.save(dd, true);
std::this_thread::sleep_for(std::chrono::seconds(1));
}
printf("Finished testing count from %d\n", cnt);
}
void ui_mgr::thread_display(void)
{
DISPDATA dd;
@ -960,6 +971,7 @@ void ui_mgr::key_event(int key)
{
if(key == (int)KeyMonitor::HGKey::Key_Cancle)
{
utils::to_log(LOG_LEVEL_DEBUG, "Do menu command: %s\n", "Stop scanning Immediately");
devui::send_message(devui::UI_CMD_STOP_SCAN);
}
@ -991,6 +1003,7 @@ void ui_mgr::key_event(int key)
else if(key == (int)KeyMonitor::HGKey::Key_Cancle)
{
// stop scanning here ...
utils::to_log(LOG_LEVEL_DEBUG, "Do menu command: %s\n", "Stop scanning Immediately");
devui::send_message(devui::UI_CMD_STOP_SCAN);
}
else if(key == -1) // interrupted by status message, we return to main menu

163
ui/dev_menu.h
View File

@ -20,6 +20,7 @@
#include <map>
#include <memory>
#include <thread>
#include <string.h>
#define MENU_ID_RETURN -1 // ID of menu item that return to parent
#define LINK_DEFINE(x, y) x##y
@ -99,13 +100,168 @@ class ui_mgr : public refer
SIZE font_size_ = {16, 16};
POINT hold_pos_ = {0, 0};
uint32_t his_cnt_;
uint32_t rol_cnt_;
std::map<int, MENU_CMD_CALLBACK> handler_;
std::unique_ptr<Lcd> lcd_;
std::unique_ptr<KeyMonitor> keyboard_;
class permanent_data : public refer
{
uint64_t history_cnt_ = 0;
uint32_t roller_cnt_ = 0;
uint32_t adden_ = 0;
uint32_t speed_ = 0;
std::string root_;
const std::string his_name_ = "history-count";
const std::string rol_name_ = "roller-count";
#pragma pack(push)
#pragma pack(1)
typedef struct _speed_time
{
uint64_t ms;
uint32_t speed;
}SPEEDTM, *LPSPEEDTM;
typedef struct _times
{
uint64_t history;
uint64_t roller;
}TIMES;
#pragma pack(pop)
std::map<uint32_t, TIMES> speed_times_;
public:
permanent_data()
{
root_ = utils::get_local_data_path() + PATH_SEPARATOR + "record";
utils::create_folder(root_.c_str());
root_ += PATH_SEPARATOR;
char buf[1024] = {0}, *ptr = buf;
FILE *src = fopen((root_ + his_name_).c_str(), "rb");
int len = 0;
LPSPEEDTM pspt = nullptr;
if(src)
{
len = fread(buf, 1, sizeof(buf), src);
fclose(src);
history_cnt_ = *(uint64_t*)buf;
len -= sizeof(history_cnt_);
ptr = buf + sizeof(history_cnt_);
pspt = (LPSPEEDTM)ptr;
for(int i = 0; i < len / sizeof(*pspt); ++i)
{
TIMES t = {0};
t.history = pspt[i].ms;
speed_times_[pspt[i].speed] = t;
}
}
src = fopen((root_ + rol_name_).c_str(), "rb");
if(src)
{
memset(buf, 0, sizeof(buf));
len = fread(buf, 1, sizeof(buf), src);
fclose(src);
roller_cnt_ = *(uint32_t*)buf;
len -= sizeof(roller_cnt_);
ptr = buf + sizeof(roller_cnt_);
pspt = (LPSPEEDTM)ptr;
for(int i = 0; i < len / sizeof(*pspt); ++i)
{
if(speed_times_.count(pspt[i].speed))
{
speed_times_[pspt[i].speed].roller = pspt[i].ms;
}
else
{
TIMES t = {0};
t.roller = pspt[i].ms;
speed_times_[pspt[i].speed] = t;
}
}
}
}
protected:
virtual ~permanent_data()
{
save();
}
public:
uint64_t history_count(void)
{
return history_cnt_;
}
uint32_t roller_count(void)
{
return roller_cnt_;
}
uint32_t increase_count(uint32_t run_ms, uint64_t* hiscnt = nullptr)
{
++adden_;
++roller_cnt_;
++history_cnt_;
speed_times_[speed_].history += run_ms;
speed_times_[speed_].roller += run_ms;
if(hiscnt)
*hiscnt = history_cnt_;
return roller_cnt_;
}
uint32_t clear_roller_count(void)
{
roller_cnt_ = 0;
for(auto& v: speed_times_)
v.second.roller = 0;
return roller_cnt_;
}
void set_speed(uint32_t speed)
{
speed_ = speed;
if(speed_times_.count(speed) == 0)
{
TIMES t = {0};
speed_times_[speed] = t;
}
}
void save(void)
{
FILE *dst = fopen((root_ + his_name_).c_str(), "wb");
if(dst)
{
fwrite(&history_cnt_, 1, sizeof(history_cnt_), dst);
for(auto& v: speed_times_)
{
SPEEDTM stm = {0};
stm.speed = v.first;
stm.ms = v.second.history;
fwrite(&stm, 1, sizeof(stm), dst);
}
fclose(dst);
}
dst = fopen((root_ + rol_name_).c_str(), "wb");
if(dst)
{
fwrite(&roller_cnt_, 1, sizeof(roller_cnt_), dst);
for(auto& v: speed_times_)
{
SPEEDTM stm = {0};
stm.speed = v.first;
stm.ms = v.second.roller;
fwrite(&stm, 1, sizeof(stm), dst);
}
fclose(dst);
}
}
};
refer_guard<permanent_data> perm_data_;
bool do_menu_command(int cmd); // return whether should hold UI ?
void init(void);
void clear(void);
@ -128,7 +284,6 @@ class ui_mgr : public refer
safe_fifo<DISPDATA> disp_data_;
safe_thread disp_thrd_;
void thread_test_hold_ui(void);
void thread_display(void);
void display_ready(void);
void set_ready_status_enabled(bool enable);

2
xmake.lua
View File

@ -61,7 +61,7 @@ add_defines("BUILD_AS_DEVICE")
add_defines("VER_MAIN=2")
add_defines("VER_FAMILY=200")
add_defines("VER_DATE=20240207")
add_defines("VER_BUILD=31")
add_defines("VER_BUILD=43")
target("conf")
set_kind("phony")