2023-12-19 07:27:16 +00:00
|
|
|
#include "hardware.h"
|
|
|
|
|
|
|
|
#include "./cis/FpgaComm.h"
|
2023-12-20 07:23:24 +00:00
|
|
|
#include "./cis/gvideoisp1.h"
|
|
|
|
#include "./motor/motorboard.h"
|
2023-12-19 07:27:16 +00:00
|
|
|
#include <huagao/hgscanner_error.h>
|
|
|
|
#include <sane/sane_ex.h>
|
2024-01-05 09:36:50 +00:00
|
|
|
#include <json/gb_json.h>
|
2024-01-11 09:59:23 +00:00
|
|
|
#include <base/paper.h>
|
2024-02-02 08:53:17 +00:00
|
|
|
#include <base/ui.h>
|
2023-12-19 07:27:16 +00:00
|
|
|
|
2024-03-08 07:04:10 +00:00
|
|
|
|
2023-12-19 07:27:16 +00:00
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// scanner_hw
|
2024-01-25 06:13:24 +00:00
|
|
|
static std::string device_opt_json[] = {
|
2024-03-12 09:47:40 +00:00
|
|
|
"{\"cis-mode\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"CIS\\u989c\\u8272\\u6a21\\u5f0f\",\"desc\":\"\\u9009\\u62e9\\u955c\\u5934\\u8272\\u5f69\\u5de5\\u4f5c\\u6a21\\u5f0f\",\"type\":\"string\",\"ui-pos\":10,\"auth\":100,\"bind\":true,\"size\":12,\"default\":{\"(mode.enabled&&(mode==256\\u7ea7\\u7070\\u5ea6||mode==\\u9ed1\\u767d)) || (multiout-type.enabled&&multiout-type==\\u7070\\u5ea6+\\u9ed1\\u767d)\":\"\\u7070\\u5ea6\",\"default\":\"\\u5f69\\u8272\"},\"range\":[\"\\u5f69\\u8272\",\"\\u7070\\u5ea6\"]},\"cis-dpi\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"CIS\\u5206\\u8fa8\\u7387\",\"desc\":\"\\u8bbe\\u7f6e\\u955c\\u5934\\u5de5\\u4f5c\\u7684\\u5206\\u8fa8\\u7387\",\"type\":\"int\",\"ui-pos\":11,\"auth\":100,\"bind\":true,\"size\":4,\"default\":{\"resolution>=400\":600,\"default\":300},\"range\":[300,600]},\"resolution\":{\"cat\":\"imgp\",\"group\":\"base\",\"title\":\"\\u5206\\u8fa8\\u7387\",\"desc\":\"\\u8bbe\\u7f6e\\u626b\\u63cf\\u56fe\\u50cf\\u7684\\u5206\\u8fa8\\u7387\",\"type\":\"int\",\"pos\":9999,\"fix-id\":34840,\"ui-pos\":20,\"auth\":0,\"affect\":6,\"unit\":\"dpi\",\"size\":4},\"cis-led\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"CIS\\u706f\",\"desc\":\"CIS\\u5de5\\u4f5c\\u65f6\\uff0c\\u662f\\u5426\\u6253\\u5f00\\u80cc\\u666f\\u706f\",\"type\":\"bool\",\"ui-pos\":12,\"auth\":100,\"size\":4,\"cur\":true,\"default\":true},\"paper\":{\"cat\":\"base\",\"group\":\"base\",\"title\":\"\\u7eb8\\u5f20\\u5c3a\\u5bf8\",\"desc\":\"\\u8bbe\\u7f6e\\u51fa\\u56fe\\u5927\\u5c0f\",\"type\":\"string\",\"fix-id\":34831,\"ui-pos\":30,\"auth\":0,\"size\":44,\"cur\":\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"default\":\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"range\":[\"A3\",\"8\\u5f00\",\"A4\",\"16\\u5f00\",\"A5\",\"A6\",\"B4\",\"B5\",\"B6\",\"Letter\",\"Double Letter\",\"LEGAL\",\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",{\"resolution<500\":\"\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\"},{\"resolution<500\":\"\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\"},{\"resolution<500\":\"\\u4e09\\u8054\\u8bd5\\u5377\"}]},\"lateral\":{\"cat\":\"base\",\"group\":\"base\",\"title\":\"\\u6a2a\\u5411\",\"desc\":\"\\u6a2a\\u5411\\u653e\\u7f6e\\u7eb8\\u5f20\",\"type\":\"bool\",\"fix-id\":34924,\"ui-pos\":31,\"auth\":0,\"affect\":6,\"size\":4,\"cur\":false,\"default\":false,\"depend\":\"paper==A4 || paper==16\\u5f00 || paper==A5 || paper==A6 || paper==B5 || paper==B6 || paper==Letter\"},\"paper-w\":{\"cat\":\"base\",\"group\":\"base\",\"title\":\"\\u7eb8\\u5f20\\u5bbd\\u5ea6\",\"desc\":\"\\u4ee5\\u6beb\\u7c73\\u4e3a\\u5355\\u4f4d\\u7684\\u7eb8\\u5f20\\u5bbd\",\"type\":\"float\",\"fix-id\":34922,\"ui-pos\":32,\"auth\":0,\"unit\":\"mm\",\"readonly\":true,\"size\":8,\"auto\":false,\"ownread\":true,\"cur\":210.000000,\"default\":210.000000},\"paper-h\":{\"cat\":\"base\",\"group\":\"base\",\"title\":\"\\u7eb8\\u5f20\\u9ad8\\u5ea6\",\"desc\":\"\\u4ee5\\u6beb\\u7c73\\u4e3a\\u5355\\u4f4d\\u7684\\u7eb8\\u5f20\\u9ad8\",\"type\":\"float\",\"fix-id\":34923,\"ui-pos\":33,\"auth\":0,\"unit\":\"mm\",\"readonly\":true,\"size\":8,\"auto\":false,\"ownread\":true,\"cur\":297.000000,\"default\":297.000000},\"is-wait-scan\":{\"cat\":\"base\",\"group\":\"feeder\",\"title\":\"\\u5f85\\u7eb8\\u626b\\u63cf\",\"desc\":\"\\u542f\\u7528\\u540e\\uff0c\\u6587\\u7a3f\\u653e\\u5165\\u626b\\u63cf\\u4eea\\u65f6\\u5c06\\u81ea\\u52a8\\u542f\\u52a8\\u626b\\u63cf\",\"type\":\"bool\",\"fix-id\":34873,\"ui-pos\":12,\"auth\":0,\"size\":4,\"cur\":false,\"default\":false},\"wait-scan-exit\":{\"cat\":\"base\",\"group\":\"feeder\",\"title\":\"\\u5f85\\u7eb8\\u626b\\u63cf\\u9000\\u51fa\\u65f6\\u95f4\",\"desc\":\"\\u8bbe\\u7f6e\\u7ed3\\u675f\\u5f85\\u7eb8\\u626b\\u63cf\\u7684\\u65f6\\u95f4\",\"type\":\"string\",\"fix-id\":34920,\"ui-pos\":13,\"auth\":0,\"size\":16,\"cur\":\"60s\",\"default\":\"60s\",\"range\":[\"15s\",\"30s\",\"60s\",\"2min\",\"4min\",\"8min\"],\"depend\":\"is-wait-scan==true\"},\"scan-mode\":{\"cat\":\"base\",\"group\":\"feeder\",\"title\":\"\\u626b\\u63cf\\u5f20\\u6570\",\"desc\":\"\\u9009\\u62e9\\u6307\\u5b9a\\u
|
|
|
|
"c\":\"\\u955c\\u5934\\u53c2\\u6570\\u63a7\\u5236\\u9a71\\u52a8\\u7a0b\\u5e8f\\u7248\\u672c\\u53f7\",\"type\":\"string\",\"ui-pos\":17,\"auth\":100,\"readonly\":true,\"size\":24,\"auto\":false,\"cur\":\"\",\"default\":\"\"},\"cis-len\":{\"cat\":\"base\",\"group\":\"about\",\"title\":\"\\u955c\\u5934\\u957f\",\"desc\":\"\\u56fe\\u50cf\\u91c7\\u96c6\\u955c\\u5934\\u7684\\u957f\\u5ea6\\uff0c\\u5355\\u4f4d\\u4e3a\\u6beb\\u7c73\\uff08mm\\uff09\",\"type\":\"int\",\"ui-pos\":30,\"auth\":100,\"unit\":\"mm\",\"readonly\":true,\"size\":4,\"auto\":false,\"cur\":3888,\"default\":3888},\"stretch-h\":{\"cat\":\"base\",\"group\":\"CIS\",\"title\":\"\\u6c34\\u5e73\\u62c9\\u4f38\\u7387\",\"desc\":\"\\u4e3a\\u62b5\\u6297\\u5f62\\u53d8\\uff0c\\u5728\\u6c34\\u5e73\\u65b9\\u5411\\u7684\\u62c9\\u4f38\\u7387\",\"type\":\"float\",\"ui-pos\":40,\"auth\":100,\"size\":8,\"auto\":false,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":1.000000,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":1.000000,\"cis-mode==\\u7070\\u5ea6 && cis-dpi==600\":1.000000,\"default\":1.000000},\"range\":{\"min\":0.500000,\"max\":2.000000,\"step\":0.100000}},\"stretch-v\":{\"cat\":\"base\",\"group\":\"CIS\",\"title\":\"\\u5782\\u76f4\\u62c9\\u4f38\\u7387\",\"desc\":\"\\u4e3a\\u62b5\\u6297\\u5f62\\u53d8\\uff0c\\u5728\\u5782\\u76f4\\u65b9\\u5411\\u7684\\u62c9\\u4f38\\u7387\",\"type\":\"float\",\"ui-pos\":41,\"auth\":100,\"size\":8,\"auto\":false,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":1.000000,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":1.000000,\"cis-mode==\\u7070\\u5ea6 && cis-dpi==600\":1.000000,\"default\":1.000000},\"range\":{\"min\":0.500000,\"max\":2.000000,\"step\":0.100000}},\"cis-sp\":{\"cat\":\"base\",\"group\":\"CIS\",\"title\":\"\\u901f\\u73871\",\"desc\":\"FPGA\\u6700\\u4f73\\u901f\\u7387\",\"type\":\"int\",\"ui-pos\":42,\"auth\":100,\"bind\":true,\"size\":4,\"auto\":false,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":2637,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":1531,\"cis-mode==\\u7070\\u5ea6 && cis-dpi==600\":4595,\"default\":816}},\"expo-fr\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"\\u66dd\\u5149\\u5ea6\\uff08\\u6b63\\u9762\\u7ea2\\u8272\\u901a\\u9053\\uff09\",\"desc\":\"\\u6b63\\u9762\\u7ea2\\u8272\\u901a\\u9053\\u7684\\u66dd\\u5149\\u5f3a\\u5ea6\",\"type\":\"int\",\"ui-pos\":70,\"auth\":100,\"bind\":true,\"size\":4,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":336,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":622,\"cis-mode==\\u7070\\u5ea6 && cis-dpi==600\":673,\"default\":313},\"range\":{\"min\":1,\"max\":1100,\"step\":1}},\"expo-fg\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"\\u66dd\\u5149\\u5ea6\\uff08\\u6b63\\u9762\\u7eff\\u8272\\u901a\\u9053\\uff09\",\"desc\":\"\\u6b63\\u9762\\u7eff\\u8272\\u901a\\u9053\\u7684\\u66dd\\u5149\\u5f3a\\u5ea6\",\"type\":\"int\",\"ui-pos\":71,\"auth\":100,\"bind\":true,\"size\":4,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":336,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":611,\"cis-mode==\\u7070\\u5ea6 && cis-dpi==600\":673,\"default\":306},\"range\":{\"min\":1,\"max\":1100,\"step\":1}},\"expo-fb\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"\\u66dd\\u5149\\u5ea6\\uff08\\u6b63\\u9762\\u84dd\\u8272\\u901a\\u9053\\uff09\",\"desc\":\"\\u6b63\\u9762\\u84dd\\u8272\\u901a\\u9053\\u7684\\u66dd\\u5149\\u5f3a\\u5ea6\",\"type\":\"int\",\"ui-pos\":72,\"auth\":100,\"bind\":true,\"size\":4,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":336,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":590,\"cis-mode==\\u7070\\u5ea6 && cis-dpi==600\":673,\"default\":297},\"range\":{\"min\":1,\"max\":1100,\"step\":1}},\"expo-br\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"\\u66dd\\u5149\\u5ea6\\uff08\\u80cc\\u9762\\u7ea2\\u8272\\u901a\\u9053\\uff09\",\"desc\":\"\\u80cc\\u9762\\u7ea2\\u8272\\u901a\\u9053\\u7684\\u66dd\\u5149\\u5f3a\\u5ea6\",\"type\":\"int\",\"ui-pos\":73,\"auth\":100,\"bind\":true,\"size\":4,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":410,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":713,\"cis-mode==\\u7070\\u5ea6 && cis-dpi
|
|
|
|
"76ca\\u91cf\",\"type\":\"int\",\"ui-pos\":124,\"auth\":100,\"bind\":true,\"size\":4,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":170,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":170,\"cis-mode==\\u7070\\u5ea6 && cis-dpi==600\":170,\"default\":170},\"range\":{\"min\":1,\"max\":200,\"step\":1}},\"gain-b-6\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"\\u589e\\u76ca\\uff08\\u80cc\\u9762\\u901a\\u90536\\uff09\",\"desc\":\"\\u80cc\\u9762\\u901a\\u90536\\u7684\\u589e\\u76ca\\u91cf\",\"type\":\"int\",\"ui-pos\":125,\"auth\":100,\"bind\":true,\"size\":4,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":170,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":170,\"cis-mode==\\u7070\\u5ea6 && cis-dpi==600\":170,\"default\":170},\"range\":{\"min\":1,\"max\":200,\"step\":1}},\"off-f-1\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"\\u589e\\u76ca\\u8865\\u507f\\uff08\\u6b63\\u9762\\u901a\\u90531\\uff09\",\"desc\":\"\\u6b63\\u9762\\u901a\\u90531\\u7684\\u589e\\u76ca\\u8865\\u507f\\u91cf\",\"type\":\"int\",\"ui-pos\":160,\"auth\":100,\"bind\":true,\"size\":4,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":116,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":115,\"cis-mode==\\u7070\\u5ea6 && cis-dpi==600\":116,\"default\":113},\"range\":{\"min\":1,\"max\":200,\"step\":1}},\"off-f-2\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"\\u589e\\u76ca\\u8865\\u507f\\uff08\\u6b63\\u9762\\u901a\\u90532\\uff09\",\"desc\":\"\\u6b63\\u9762\\u901a\\u90532\\u7684\\u589e\\u76ca\\u8865\\u507f\\u91cf\",\"type\":\"int\",\"ui-pos\":161,\"auth\":100,\"bind\":true,\"size\":4,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":121,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":119,\"cis-mode==\\u7070\\u5ea6 && cis-dpi==600\":121,\"default\":118},\"range\":{\"min\":1,\"max\":200,\"step\":1}},\"off-f-3\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"\\u589e\\u76ca\\u8865\\u507f\\uff08\\u6b63\\u9762\\u901a\\u90533\\uff09\",\"desc\":\"\\u6b63\\u9762\\u901a\\u90533\\u7684\\u589e\\u76ca\\u8865\\u507f\\u91cf\",\"type\":\"int\",\"ui-pos\":162,\"auth\":100,\"bind\":true,\"size\":4,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":119,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":118,\"cis-mode==\\u7070\\u5ea6 && cis-dpi==600\":121,\"default\":118},\"range\":{\"min\":1,\"max\":200,\"step\":1}},\"off-f-4\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"\\u589e\\u76ca\\u8865\\u507f\\uff08\\u6b63\\u9762\\u901a\\u90534\\uff09\",\"desc\":\"\\u6b63\\u9762\\u901a\\u90534\\u7684\\u589e\\u76ca\\u8865\\u507f\\u91cf\",\"type\":\"int\",\"ui-pos\":163,\"auth\":100,\"bind\":true,\"size\":4,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":128,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":126,\"cis-mode==\\u7070\\u5ea6 && cis-dpi==600\":129,\"default\":124},\"range\":{\"min\":1,\"max\":200,\"step\":1}},\"off-f-5\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"\\u589e\\u76ca\\u8865\\u507f\\uff08\\u6b63\\u9762\\u901a\\u90535\\uff09\",\"desc\":\"\\u6b63\\u9762\\u901a\\u90535\\u7684\\u589e\\u76ca\\u8865\\u507f\\u91cf\",\"type\":\"int\",\"ui-pos\":164,\"auth\":100,\"bind\":true,\"size\":4,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":129,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":127,\"cis-mode==\\u7070\\u5ea6 && cis-dpi==600\":130,\"default\":126},\"range\":{\"min\":1,\"max\":200,\"step\":1}},\"off-f-6\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"\\u589e\\u76ca\\u8865\\u507f\\uff08\\u6b63\\u9762\\u901a\\u90536\\uff09\",\"desc\":\"\\u6b63\\u9762\\u901a\\u90536\\u7684\\u589e\\u76ca\\u8865\\u507f\\u91cf\",\"type\":\"int\",\"ui-pos\":165,\"auth\":100,\"bind\":true,\"size\":4,\"default\":{\"cis-mode==\\u7070\\u5ea6 && cis-dpi==300\":127,\"cis-mode==\\u5f69\\u8272 && cis-dpi==600\":125,\"cis-mode==\\u7070\\u5ea6 && cis-dpi==600\":127,\"default\":125},\"range\":{\"min\":1,\"max\":200,\"step\":1}},\"off-b-1\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"\\u589e\\u76ca\\u8865\\u507f\\uff08\\u80cc\\u9762\\u901a\\u90531\\uff09\",\"desc\":\"\\u80cc\\u9762\\u901a\\u90531\\u7684\\u589e\\u76ca\\u8865\\u507f\\u91cf\",\"type\":\
|
2023-12-19 07:27:16 +00:00
|
|
|
};
|
2024-03-09 05:50:53 +00:00
|
|
|
|
2023-12-19 07:27:16 +00:00
|
|
|
|
2024-01-30 03:43:06 +00:00
|
|
|
|
2023-12-19 07:27:16 +00:00
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// scanner_hw
|
2024-01-09 07:32:03 +00:00
|
|
|
scanner_hw::scanner_hw() : mb_events_("motorboard-event")
|
2023-12-19 07:27:16 +00:00
|
|
|
{
|
|
|
|
set_where("hardware");
|
2024-02-07 08:26:23 +00:00
|
|
|
mb_events_.enable_wait_log(false);
|
2024-01-16 09:51:34 +00:00
|
|
|
memset(&img_base_, 0, sizeof(img_base_));
|
|
|
|
img_base_.bpp = 8;
|
|
|
|
img_base_.bppc = 8;
|
|
|
|
img_base_.channels = 1;
|
|
|
|
img_base_.format = IMG_FMT_BMP;
|
|
|
|
img_base_.resolution_x = dpi_;
|
2024-01-19 08:54:58 +00:00
|
|
|
img_base_.resolution_y = dpi_y_;
|
|
|
|
img_base_.width = cis::get_line_stream_length(dpi_, true) * 2/*two sides*/;
|
2024-01-16 09:51:34 +00:00
|
|
|
img_base_.height = 16380;
|
|
|
|
img_base_.pos.new_img = true;
|
|
|
|
img_base_.pos.img_over = true;
|
|
|
|
img_base_.pos.paper_side = PAPER_SIDE_DSP;
|
2024-01-09 07:32:03 +00:00
|
|
|
|
2024-01-13 09:14:12 +00:00
|
|
|
CLEAN_ARRAY(exposure_);
|
|
|
|
CLEAN_ARRAY(gain_);
|
|
|
|
CLEAN_ARRAY(off_);
|
2024-02-21 09:44:32 +00:00
|
|
|
cis::update_correct_data();
|
2024-01-13 09:14:12 +00:00
|
|
|
|
2023-12-19 07:27:16 +00:00
|
|
|
init();
|
|
|
|
}
|
|
|
|
scanner_hw::~scanner_hw()
|
|
|
|
{
|
|
|
|
close();
|
|
|
|
}
|
|
|
|
|
|
|
|
void scanner_hw::init(void)
|
|
|
|
{
|
|
|
|
std::string text("");
|
|
|
|
|
|
|
|
for(auto& v: device_opt_json)
|
|
|
|
text += v;
|
2024-01-05 09:36:50 +00:00
|
|
|
init_version(text);
|
2024-02-21 09:44:32 +00:00
|
|
|
load_correct_data(text);
|
2023-12-19 07:27:16 +00:00
|
|
|
set_opt_json_text(&text[0]);
|
|
|
|
|
2024-01-02 07:18:42 +00:00
|
|
|
#define OPT_HANDLER(name) \
|
|
|
|
auto name = [this](void* value) -> void
|
|
|
|
|
2023-12-19 09:11:41 +00:00
|
|
|
auto a = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
auto_scan_ = *(bool*)value;
|
|
|
|
};
|
|
|
|
auto e = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
if(strcmp((char*)value, "15s") == 0)
|
|
|
|
time_to_exit_auto_scan_ = 15;
|
|
|
|
else if(strcmp((char*)value, "30s") == 0)
|
|
|
|
time_to_exit_auto_scan_ = 30;
|
|
|
|
else if(strcmp((char*)value, "2min") == 0)
|
|
|
|
time_to_exit_auto_scan_ = 120;
|
|
|
|
else if(strcmp((char*)value, "4min") == 0)
|
|
|
|
time_to_exit_auto_scan_ = 240;
|
|
|
|
else if(strcmp((char*)value, "8min") == 0)
|
|
|
|
time_to_exit_auto_scan_ = 480;
|
|
|
|
else
|
|
|
|
time_to_exit_auto_scan_ = 60;
|
|
|
|
};
|
|
|
|
|
2023-12-19 07:27:16 +00:00
|
|
|
auto m = [this](void* value) -> void
|
|
|
|
{
|
2024-01-24 04:05:05 +00:00
|
|
|
if(strcmp((char*)value, WORDS_COLOR_GRAY) == 0)
|
2023-12-19 07:27:16 +00:00
|
|
|
mode_ = (char*)value;
|
|
|
|
else
|
2024-01-24 04:05:05 +00:00
|
|
|
mode_ = WORDS_COLOR_COLOR;
|
2023-12-19 07:27:16 +00:00
|
|
|
};
|
|
|
|
auto r = [this](void* value) -> void
|
|
|
|
{
|
2024-01-16 09:51:34 +00:00
|
|
|
dpi_ = *(int*)value;
|
2023-12-19 07:27:16 +00:00
|
|
|
};
|
2024-01-19 08:54:58 +00:00
|
|
|
auto y = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
dpi_y_ = *(int*)value;
|
|
|
|
};
|
2023-12-19 07:27:16 +00:00
|
|
|
auto b = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
baud_ = *(int*)value;
|
|
|
|
};
|
|
|
|
auto d = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
delay_ = *(int*)value;
|
|
|
|
};
|
|
|
|
auto f = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
frame_h_ = *(int*)value;
|
|
|
|
};
|
|
|
|
auto s = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
sample_ = *(int*)value;
|
|
|
|
};
|
2024-01-13 09:14:12 +00:00
|
|
|
auto sp = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
sp_ = *(int*)value;
|
|
|
|
};
|
2024-01-27 09:43:13 +00:00
|
|
|
OPT_HANDLER(pha)
|
|
|
|
{
|
|
|
|
vsp_a_ = *(int*)value;
|
|
|
|
};
|
|
|
|
OPT_HANDLER(phb)
|
|
|
|
{
|
|
|
|
vsp_b_ = *(int*)value;
|
|
|
|
};
|
2024-01-16 09:51:34 +00:00
|
|
|
auto led = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
cis_led_ = *(bool*)value;
|
|
|
|
};
|
2024-01-13 09:14:12 +00:00
|
|
|
auto stretch_h = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
stretch_h_ = *(double*)value;
|
|
|
|
};
|
|
|
|
auto stretch_v = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
stretch_v_ = *(double*)value;
|
|
|
|
};
|
2023-12-19 07:27:16 +00:00
|
|
|
|
|
|
|
auto efb = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
exposure_[SIDE_FRONT][COLOR_IND_BLUE] = *(int*)value;
|
|
|
|
};
|
|
|
|
auto efg = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
exposure_[SIDE_FRONT][COLOR_IND_GREEN] = *(int*)value;
|
|
|
|
};
|
|
|
|
auto efr = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
exposure_[SIDE_FRONT][COLOR_IND_RED] = *(int*)value;
|
|
|
|
};
|
|
|
|
auto ebb = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
exposure_[SIDE_BACK][COLOR_IND_BLUE] = *(int*)value;
|
|
|
|
};
|
|
|
|
auto ebg = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
exposure_[SIDE_BACK][COLOR_IND_GREEN] = *(int*)value;
|
|
|
|
};
|
|
|
|
auto ebr = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
exposure_[SIDE_BACK][COLOR_IND_RED] = *(int*)value;
|
|
|
|
};
|
|
|
|
|
2023-12-19 09:11:41 +00:00
|
|
|
CLEAN_ARRAY(exposure_);
|
|
|
|
CLEAN_ARRAY(gain_);
|
|
|
|
CLEAN_ARRAY(off_);
|
|
|
|
|
2024-01-31 01:41:22 +00:00
|
|
|
opt_handler_[SANE_OPT_NAME(WAIT_TO_SCAN)] = a;
|
|
|
|
opt_handler_[SANE_OPT_NAME(WAIT_SCAN_EXIT)] = e;
|
|
|
|
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_MODE)] = m;
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_DPI)] = r;
|
2024-03-12 08:25:55 +00:00
|
|
|
opt_handler_[SANE_OPT_NAME(RESOLUTION)] = y;
|
2024-01-31 01:41:22 +00:00
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_BAUD)] = b;
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_DELAY)] = d;
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_FRAME_H)] = f;
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_SAMPLE)] = s;
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_SP)] = sp;
|
|
|
|
opt_handler_[SANE_OPT_NAME(PHASE_FRONT)] = pha;
|
|
|
|
opt_handler_[SANE_OPT_NAME(PHASE_BACK)] = phb;
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_LED)] = led;
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_STRETCH_H)] = stretch_h;
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_STRETCH_V)] = stretch_v;
|
|
|
|
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_EXPO_FB)] = efb;
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_EXPO_FG)] = efg;
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_EXPO_FR)] = efr;
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_EXPO_BB)] = ebb;
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_EXPO_BG)] = ebg;
|
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_EXPO_BR)] = ebr;
|
2023-12-19 07:27:16 +00:00
|
|
|
|
2023-12-20 08:44:39 +00:00
|
|
|
|
2024-01-11 09:59:23 +00:00
|
|
|
auto p = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
paper_ = (char*)value;
|
|
|
|
};
|
|
|
|
auto l = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
lateral_ = *(bool*)value;
|
|
|
|
};
|
|
|
|
|
2024-01-31 01:41:22 +00:00
|
|
|
opt_handler_[SANE_OPT_NAME(PAPER)] = p;
|
|
|
|
opt_handler_[SANE_OPT_NAME(LATERAL)] = l;
|
2024-01-11 09:59:23 +00:00
|
|
|
|
2023-12-20 08:44:39 +00:00
|
|
|
auto staple = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
staple_chk_ = *(bool*)value;
|
|
|
|
};
|
|
|
|
auto screw = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
screw_chk_ = *(bool*)value;
|
|
|
|
};
|
2023-12-29 02:53:04 +00:00
|
|
|
auto screwl = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
screw_chk_level_ = *(int*)value;
|
|
|
|
};
|
2023-12-20 08:44:39 +00:00
|
|
|
auto dbchk = [this](void* value) -> void
|
|
|
|
{
|
2024-01-24 04:05:05 +00:00
|
|
|
double_chk_ = strcmp((char*)value, WORDS_FORBIDDEN) != 0;
|
2023-12-20 08:44:39 +00:00
|
|
|
};
|
|
|
|
auto motsp = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
int speed = *(int*)value;
|
2023-12-29 08:58:41 +00:00
|
|
|
if(family_ == "G200")
|
2023-12-29 02:53:04 +00:00
|
|
|
{
|
2023-12-29 08:58:41 +00:00
|
|
|
speed -= 100; // 100 110 120 130
|
2023-12-29 02:53:04 +00:00
|
|
|
}
|
2023-12-20 08:44:39 +00:00
|
|
|
else
|
2023-12-29 02:53:04 +00:00
|
|
|
{
|
2023-12-29 08:58:41 +00:00
|
|
|
speed -= 70; // 70 80 90 100
|
2023-12-29 02:53:04 +00:00
|
|
|
}
|
|
|
|
switch(speed)
|
|
|
|
{
|
|
|
|
case 10:
|
|
|
|
motor_speed_ = SPEED_PPM_BASE_10;
|
|
|
|
break;
|
|
|
|
case 20:
|
|
|
|
motor_speed_ = SPEED_PPM_BASE_20;
|
|
|
|
break;
|
|
|
|
case 30:
|
|
|
|
motor_speed_ = SPEED_PPM_BASE_30;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
motor_speed_ = SPEED_PPM_BASE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
auto fm = [this](void* value) -> void
|
|
|
|
{
|
|
|
|
family_ = (char*)value;
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Device family set as: %s\n", family_.c_str());
|
2023-12-20 08:44:39 +00:00
|
|
|
};
|
2024-01-02 07:18:42 +00:00
|
|
|
OPT_HANDLER(cntm)
|
|
|
|
{
|
2024-01-24 04:05:05 +00:00
|
|
|
scan_cntless_ = strcmp((char*)value, WORDS_SCAN_CONTINUOUS) == 0;
|
2024-01-02 07:18:42 +00:00
|
|
|
};
|
|
|
|
OPT_HANDLER(cnt)
|
|
|
|
{
|
|
|
|
scan_count_ = *(int*)value;
|
|
|
|
};
|
|
|
|
OPT_HANDLER(afs)
|
|
|
|
{
|
|
|
|
|
|
|
|
};
|
|
|
|
OPT_HANDLER(ff)
|
|
|
|
{
|
|
|
|
|
|
|
|
};
|
|
|
|
OPT_HANDLER(fs)
|
|
|
|
{
|
|
|
|
|
|
|
|
};
|
|
|
|
OPT_HANDLER(slp)
|
|
|
|
{
|
|
|
|
|
|
|
|
};
|
2024-03-12 08:25:55 +00:00
|
|
|
OPT_HANDLER(papertm)
|
2024-03-21 09:44:43 +00:00
|
|
|
{
|
|
|
|
log_debug_info_ = *(bool*)value;
|
2024-03-12 08:25:55 +00:00
|
|
|
};
|
2023-12-20 08:44:39 +00:00
|
|
|
|
2024-01-31 01:41:22 +00:00
|
|
|
opt_handler_[SANE_OPT_NAME(IS_CHECK_STAPLE)] = staple;
|
|
|
|
opt_handler_[SANE_OPT_NAME(IS_CHECK_ASKEW)] = screw;
|
|
|
|
opt_handler_[SANE_OPT_NAME(ASKEW_RANGE)] = screwl;
|
|
|
|
opt_handler_[SANE_OPT_NAME(DOUBLE_CHECK)] = dbchk;
|
|
|
|
opt_handler_[SANE_OPT_NAME(MOTOR_SPEED)] = motsp;
|
|
|
|
opt_handler_[SANE_OPT_NAME(DEVICE_MODEL)] = fm;
|
|
|
|
opt_handler_[SANE_OPT_NAME(SCAN_MODE)] = cntm;
|
|
|
|
opt_handler_[SANE_OPT_NAME(SCAN_COUNT)] = cnt;
|
|
|
|
opt_handler_[SANE_OPT_NAME(IS_AUTO_FEED_STRENGTH)] = afs;
|
|
|
|
opt_handler_[SANE_OPT_NAME(FEED_STRENGTH_VALUE)] = ff;
|
2024-03-12 08:25:55 +00:00
|
|
|
opt_handler_[SANE_OPT_NAME(CIS_PAPER_TIME)] = papertm;
|
2024-01-31 01:41:22 +00:00
|
|
|
opt_handler_[SANE_OPT_NAME(FEED_STRENGTH)] = fs;
|
|
|
|
opt_handler_[SANE_OPT_NAME(TIME_TO_SLEEP)] = slp;
|
2024-01-02 07:18:42 +00:00
|
|
|
}
|
2024-01-05 09:36:50 +00:00
|
|
|
void scanner_hw::init_version(std::string& text)
|
|
|
|
{
|
|
|
|
gb_json *jsn = new gb_json();
|
|
|
|
|
|
|
|
if(jsn->attach_text(&text[0]))
|
|
|
|
{
|
|
|
|
gb_json *child = nullptr;
|
2024-01-31 01:41:22 +00:00
|
|
|
jsn->get_value(SANE_OPT_NAME(MOTOR_VER), child);
|
2024-01-05 09:36:50 +00:00
|
|
|
if(child)
|
|
|
|
{
|
|
|
|
unsigned int val = 0;
|
|
|
|
char buf[20] = {0};
|
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
motor_.reset(new MotorBoard(nullptr));
|
|
|
|
motor_->read(MB_PORT_VERSION, val);
|
2024-01-19 08:54:58 +00:00
|
|
|
motor_->stop(); // stop if previous process crashed
|
2024-01-05 09:36:50 +00:00
|
|
|
motor_.reset();
|
|
|
|
|
|
|
|
sprintf(buf, "%u", val);
|
|
|
|
child->set_value("cur", buf);
|
|
|
|
child->set_value("default", buf);
|
|
|
|
child->release();
|
|
|
|
}
|
|
|
|
|
2024-01-31 01:41:22 +00:00
|
|
|
jsn->get_value(SANE_OPT_NAME(FPGA_VER), child);
|
2024-01-05 09:36:50 +00:00
|
|
|
if(child)
|
|
|
|
{
|
|
|
|
unsigned int val = 0;
|
|
|
|
char buf[20] = {0};
|
|
|
|
|
|
|
|
img_controller_.reset(new FpgaComm(baud_, true));
|
|
|
|
img_controller_->read(MAX_REGS - 1, val);
|
|
|
|
img_controller_.reset();
|
|
|
|
|
|
|
|
sprintf(buf, "0x%08x", val);
|
|
|
|
child->set_value("cur", buf);
|
|
|
|
child->set_value("default", buf);
|
|
|
|
child->release();
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
|
2024-01-31 01:41:22 +00:00
|
|
|
jsn->get_value(SANE_OPT_NAME(CIS_LENGTH), child);
|
2024-01-09 06:26:46 +00:00
|
|
|
if(child)
|
|
|
|
{
|
|
|
|
child->get_value("default", cis_length_);
|
|
|
|
child->release();
|
|
|
|
}
|
|
|
|
|
2024-01-05 09:36:50 +00:00
|
|
|
text = jsn->to_string();
|
|
|
|
}
|
|
|
|
jsn->release();
|
|
|
|
}
|
2024-02-21 09:44:32 +00:00
|
|
|
void scanner_hw::load_correct_data(std::string& text)
|
|
|
|
{
|
|
|
|
gb_json *root = new gb_json();
|
|
|
|
|
|
|
|
if(root->attach_text(&text[0]))
|
|
|
|
{
|
|
|
|
cis::load_correct_data_to_json(root);
|
|
|
|
text = root->to_string();
|
|
|
|
}
|
|
|
|
root->release();
|
|
|
|
}
|
2024-02-07 08:26:23 +00:00
|
|
|
void scanner_hw::thread_image_capture(bool paper_ready)
|
2024-01-02 07:18:42 +00:00
|
|
|
{
|
2024-01-16 09:51:34 +00:00
|
|
|
PACKIMAGE img(img_base_);
|
2024-01-03 09:39:16 +00:00
|
|
|
safe_fifo<int> avail_mem("v4l2-mem");
|
2024-02-26 09:25:02 +00:00
|
|
|
int used_v4l2_mem = 0, times = 0,
|
|
|
|
err = SCANNER_ERR_OK, over_msg_id = 0;;
|
2024-02-07 08:26:23 +00:00
|
|
|
devui::SCANSTREAM scanstream;
|
2024-01-09 07:32:03 +00:00
|
|
|
std::pair<int, int> mbev;
|
2024-02-02 08:53:17 +00:00
|
|
|
std::function<IMAGE_HANDLER_PROTO> img_callback(img_handler_);
|
2024-01-09 07:32:03 +00:00
|
|
|
|
2024-01-03 09:39:16 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "scanning thread working ...\n");
|
2024-03-08 07:04:10 +00:00
|
|
|
|
|
|
|
#ifdef BIND_CPU
|
|
|
|
std::vector<int> cpu;
|
|
|
|
|
|
|
|
for(int i = 0; i < CPU_MAJOR_CNT; ++i)
|
|
|
|
cpu.push_back(CPU_MAJOR_0 + i);
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "set capture thread to CPU %d = %d\n", CPU_MAJOR_0, utils::set_cpu_affinity(&cpu[0], cpu.size()));
|
|
|
|
#endif
|
2024-03-07 08:00:48 +00:00
|
|
|
|
2024-03-08 07:34:39 +00:00
|
|
|
img.pos.paper_all = 1;
|
|
|
|
img.pos.ind_in_paper = 0;
|
2024-02-26 09:25:02 +00:00
|
|
|
avail_mem.enable_wait_log(false);
|
2024-01-09 06:26:46 +00:00
|
|
|
motor_->clear_error();
|
2024-03-08 07:34:39 +00:00
|
|
|
|
2024-02-07 08:26:23 +00:00
|
|
|
if(paper_ready)
|
2024-01-19 08:54:58 +00:00
|
|
|
motor_->start();
|
2024-02-07 08:26:23 +00:00
|
|
|
scanstream.mode = count_mode_ ? devui::SCAN_COUNT_MODE : devui::SCAN_NORMAL;
|
|
|
|
scanstream.speed = sp_;
|
2024-02-20 03:29:26 +00:00
|
|
|
scanstream.err = 0;
|
2024-02-07 08:26:23 +00:00
|
|
|
devui::send_message(devui::UI_STATUS_SCANNING, (uint8_t*)&scanstream, sizeof(scanstream));
|
|
|
|
while(scanning_) // auto scan cycle ...
|
2024-01-02 07:18:42 +00:00
|
|
|
{
|
2024-02-26 09:25:02 +00:00
|
|
|
// scanning ONE turn ...
|
|
|
|
if(paper_ready) // auto_scan_ ignore no paper
|
2024-02-07 08:26:23 +00:00
|
|
|
{
|
2024-02-28 02:28:42 +00:00
|
|
|
bool over = false;
|
2024-02-27 04:03:51 +00:00
|
|
|
err = start_and_wait_lifter(to_lifter_, &over_msg_id);
|
|
|
|
if(err)
|
|
|
|
break;
|
2024-03-01 09:16:12 +00:00
|
|
|
|
|
|
|
uint64_t bgn = chronograph::from_process_born();
|
|
|
|
uint32_t cnt0 = img.pos.paper_ind;
|
2024-02-07 08:26:23 +00:00
|
|
|
motor_->pick_paper();
|
2024-02-28 02:28:42 +00:00
|
|
|
err = scan_one_turn(&img, &avail_mem, &used_v4l2_mem, &over_msg_id, &over);
|
2024-03-01 09:16:12 +00:00
|
|
|
bgn = chronograph::from_process_born() - bgn;
|
|
|
|
cnt0 = img.pos.paper_ind - cnt0;
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Scanned %d papers in %dms.\n", cnt0, (int)bgn);
|
2024-02-28 02:28:42 +00:00
|
|
|
if((over && !auto_scan_) || err || !auto_scan_ || !scanning_)
|
2024-02-26 09:25:02 +00:00
|
|
|
break;
|
2024-02-28 02:28:42 +00:00
|
|
|
{
|
|
|
|
scanstream.err = over_msg_id;
|
|
|
|
scanstream.mode = devui::SCAN_PAUSED;
|
|
|
|
devui::send_message(devui::UI_STATUS_SCANNING, (uint8_t*)&scanstream, sizeof(scanstream));
|
|
|
|
}
|
2024-02-07 04:43:27 +00:00
|
|
|
}
|
2024-02-26 09:25:02 +00:00
|
|
|
|
2024-01-03 09:39:16 +00:00
|
|
|
// wait paper ...
|
2024-03-09 05:50:53 +00:00
|
|
|
if(auto_scan_)
|
2024-02-07 04:43:27 +00:00
|
|
|
{
|
2024-03-09 05:50:53 +00:00
|
|
|
chronograph watch;
|
|
|
|
bool waited = false;
|
|
|
|
while(watch.elapse_s() < time_to_exit_auto_scan_)
|
2024-02-07 04:43:27 +00:00
|
|
|
{
|
2024-03-09 05:50:53 +00:00
|
|
|
int err = 0,
|
|
|
|
fatal = 0;
|
|
|
|
if(motor_->wait_event(MOTOR_BORD_EVENT_PAPER_READY, &err, SEC_2_MS(5), &fatal, nullptr))
|
|
|
|
{
|
|
|
|
paper_ready = true;
|
|
|
|
if(scanning_)
|
|
|
|
{
|
|
|
|
waited = true;
|
|
|
|
motor_->start();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2024-03-09 07:38:23 +00:00
|
|
|
else if(fatal == MOTOR_BORD_EVENT_SCAN_DONE)
|
|
|
|
{
|
|
|
|
motor_->clear_error();
|
|
|
|
}
|
2024-03-12 08:25:55 +00:00
|
|
|
else if(!scanning_)
|
|
|
|
break;
|
2024-02-07 04:43:27 +00:00
|
|
|
}
|
2024-03-09 05:50:53 +00:00
|
|
|
if(!waited)
|
|
|
|
break;
|
2024-02-07 04:43:27 +00:00
|
|
|
}
|
2024-02-26 09:25:02 +00:00
|
|
|
|
|
|
|
// retrieve v4l2-mem ...
|
2024-02-28 02:28:42 +00:00
|
|
|
if(!count_mode_)
|
|
|
|
retrieve_v4l2_mem(&avail_mem, &used_v4l2_mem);
|
2024-01-03 09:39:16 +00:00
|
|
|
}
|
|
|
|
|
2024-02-26 09:25:02 +00:00
|
|
|
motor_->set_auto_paper(false, false);
|
|
|
|
motor_->stop();
|
2024-01-23 07:07:17 +00:00
|
|
|
|
2024-01-03 09:39:16 +00:00
|
|
|
while(used_v4l2_mem)
|
|
|
|
{
|
|
|
|
if(times++ == 0)
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Wait to retrieve %d V4L2 memory(s) ...\n", used_v4l2_mem);
|
2024-03-07 08:00:48 +00:00
|
|
|
else if(times >= 2000)
|
2024-01-03 09:39:16 +00:00
|
|
|
{
|
|
|
|
utils::to_log(LOG_LEVEL_FATAL, "Wait %d times, but %d V4L2 memory(s) has not returned yet!\n", times, used_v4l2_mem);
|
|
|
|
break;
|
|
|
|
}
|
2024-03-07 08:00:48 +00:00
|
|
|
int old = used_v4l2_mem;
|
2024-01-03 09:39:16 +00:00
|
|
|
retrieve_v4l2_mem(&avail_mem, &used_v4l2_mem);
|
2024-03-07 08:00:48 +00:00
|
|
|
if(used_v4l2_mem < old)
|
|
|
|
times = 1;
|
2024-01-03 09:39:16 +00:00
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
|
|
|
}
|
2024-02-20 03:29:26 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "scanning thread exited with error: %d.\n", err);
|
2024-02-07 04:43:27 +00:00
|
|
|
|
|
|
|
{
|
2024-02-26 09:25:02 +00:00
|
|
|
scanstream.err = over_msg_id;
|
2024-02-20 03:29:26 +00:00
|
|
|
scanstream.mode = devui::SCAN_STOPPED;
|
|
|
|
devui::send_message(devui::UI_STATUS_SCANNING, (uint8_t*)&scanstream, sizeof(scanstream));
|
2024-02-07 04:43:27 +00:00
|
|
|
}
|
2024-01-05 09:36:50 +00:00
|
|
|
|
|
|
|
scanning_ = false;
|
2024-03-21 09:44:43 +00:00
|
|
|
img_callback((dyn_mem_ptr)WORKER_STATUS_IDLE, CIS_CB_SCAN_OVER, (LPPACKIMAGE)err);
|
2024-01-02 07:18:42 +00:00
|
|
|
}
|
2024-02-26 09:25:02 +00:00
|
|
|
int scanner_hw::start_and_wait_lifter(int to_ms, int* ui_words_id)
|
|
|
|
{
|
|
|
|
int ret = SCANNER_ERR_DEVICE_FEEDER_POS,
|
2024-03-07 08:00:48 +00:00
|
|
|
words = ID_WORDS_STATUS_DEVICE_HD_001,
|
|
|
|
err = 0;
|
2024-02-26 09:25:02 +00:00
|
|
|
|
2024-03-07 08:00:48 +00:00
|
|
|
if(motor_->wait_event(MOTOR_BORD_EVENT_LIFTER_READY, &ret, to_ms, &err, &words))
|
|
|
|
ret = words = 0;
|
|
|
|
|
2024-02-26 09:25:02 +00:00
|
|
|
if(!scanning_) // user cancelled
|
|
|
|
{
|
|
|
|
ret = SCANNER_ERR_USER_CANCELED;
|
|
|
|
words = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(ui_words_id)
|
|
|
|
*ui_words_id = words;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2024-02-28 02:28:42 +00:00
|
|
|
int scanner_hw::scan_one_turn(LPPACKIMAGE img, safe_fifo<int>* cism, int* cism_cnt, int* ui_words, bool* mbstopped)
|
2024-02-26 09:25:02 +00:00
|
|
|
{
|
2024-03-21 09:44:43 +00:00
|
|
|
int ret = SCANNER_ERR_OK, minh = 210 * dpi_y_ / MM_PER_INCH,
|
2024-02-26 09:25:02 +00:00
|
|
|
words = 0;
|
2024-03-21 09:44:43 +00:00
|
|
|
bool resok = true;
|
2024-02-26 09:25:02 +00:00
|
|
|
uint32_t pass = 0;
|
2024-03-21 09:44:43 +00:00
|
|
|
uint64_t bgn = chronograph::from_process_born();
|
2024-02-26 09:25:02 +00:00
|
|
|
chronograph watch;
|
2024-03-21 09:44:43 +00:00
|
|
|
std::string loginfo("");
|
2024-02-26 09:25:02 +00:00
|
|
|
std::pair<int, int> mbev;
|
2024-03-07 08:00:48 +00:00
|
|
|
dyn_mem_shared_ptr mem = nullptr;
|
2024-03-08 07:04:10 +00:00
|
|
|
std::function<IMAGE_HANDLER_PROTO> img_callback(img_handler_);
|
2024-02-26 09:25:02 +00:00
|
|
|
|
|
|
|
auto put_v4l2_mem = [&](BEFORE_DESTROY_PARAM) -> BEFORE_DESTROY_RET
|
|
|
|
{
|
|
|
|
int ind = (int)(long)mem->get_param(1);
|
|
|
|
safe_fifo<int>* que = (safe_fifo<int>*)mem->get_param(0);
|
|
|
|
|
|
|
|
mem->detach(nullptr);
|
|
|
|
que->save(ind);
|
|
|
|
};
|
|
|
|
|
2024-02-28 02:28:42 +00:00
|
|
|
if(mbstopped)
|
|
|
|
*mbstopped = false;
|
2024-02-29 07:45:50 +00:00
|
|
|
img->life = chronograph::from_process_born();
|
2024-02-26 09:25:02 +00:00
|
|
|
while(scanning_)
|
|
|
|
{
|
2024-03-07 08:00:48 +00:00
|
|
|
int fatal = 0;
|
|
|
|
ret = SCANNER_ERR_DEVICE_HD_002;
|
|
|
|
words = ID_WORDS_STATUS_DEVICE_HD_002;
|
2024-03-08 07:04:10 +00:00
|
|
|
|
2024-03-07 08:00:48 +00:00
|
|
|
if(!motor_->wait_event(MOTOR_BORD_EVENT_PAPER_PASSING, &ret, to_paper_out_, &fatal, &words))
|
2024-02-26 09:25:02 +00:00
|
|
|
{
|
|
|
|
if(ret != SCANNER_ERR_DEVICE_DOUBLE_FEEDING)
|
|
|
|
{
|
2024-03-07 08:00:48 +00:00
|
|
|
if(fatal == MOTOR_BORD_EVENT_SCAN_DONE)
|
|
|
|
{
|
|
|
|
ret = words = 0;
|
|
|
|
if(mbstopped)
|
|
|
|
*mbstopped = true;
|
|
|
|
printf("-->scan done event received from motorboard.\n");
|
2024-03-21 07:16:39 +00:00
|
|
|
utils::to_log(LOG_LEVEL_ALL, "scan done from motorboard.\n");
|
2024-03-07 08:00:48 +00:00
|
|
|
}
|
|
|
|
// else
|
|
|
|
break;
|
2024-02-26 09:25:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = SCANNER_ERR_OK;
|
|
|
|
words = 0;
|
|
|
|
}
|
2024-03-21 09:44:43 +00:00
|
|
|
dbg_print_(loginfo, img->pos.paper_ind + 1, "paperout", chronograph::from_process_born() - bgn, false);
|
2024-02-26 09:25:02 +00:00
|
|
|
|
2024-03-07 08:00:48 +00:00
|
|
|
pass = watch.elapse_ms();
|
2024-02-26 09:25:02 +00:00
|
|
|
img->pos.paper_ind++;
|
|
|
|
|
2024-03-09 09:47:57 +00:00
|
|
|
if(!count_mode_)
|
2024-02-26 09:25:02 +00:00
|
|
|
{
|
|
|
|
img->height = get_image_real_height(minh);
|
2024-03-21 09:44:43 +00:00
|
|
|
dbg_print_(loginfo, img->pos.paper_ind, "getheight", chronograph::from_process_born() - bgn, false);
|
2024-02-26 09:25:02 +00:00
|
|
|
|
|
|
|
size_t size = 0;
|
|
|
|
int ind = -1;
|
|
|
|
void* frame = camera_->read_frame(to_stream_, size, ind);
|
|
|
|
|
2024-03-21 09:44:43 +00:00
|
|
|
dbg_print_(loginfo, img->pos.paper_ind, "rdframe", chronograph::from_process_born() - bgn, false);
|
2024-02-26 09:25:02 +00:00
|
|
|
if(!frame)
|
|
|
|
{
|
2024-03-07 08:00:48 +00:00
|
|
|
if(fatal != MOTOR_BORD_EVENT_SCAN_DONE)
|
|
|
|
{
|
|
|
|
ret = SCANNER_ERR_DEVICE_CIS_STREAM;
|
|
|
|
words = ID_WORDS_STATUS_CAPTURE_FAILED;
|
|
|
|
}
|
2024-02-26 09:25:02 +00:00
|
|
|
break;
|
|
|
|
}
|
2024-03-01 09:16:12 +00:00
|
|
|
cism_cnt[0]++;
|
2024-02-26 09:25:02 +00:00
|
|
|
devui::send_message(devui::UI_STATUS_PAPER_CNT, (uint8_t*)&pass, sizeof(pass));
|
|
|
|
|
|
|
|
img->prc_time = watch.elapse_ms();
|
|
|
|
mem = new dyn_mem_shared(frame, size, put_v4l2_mem);
|
|
|
|
mem->set_param(cism, 0);
|
|
|
|
mem->set_param((void*)(long)ind, 1);
|
|
|
|
img->pos.status = hg_err_2_image_status(ret);
|
2024-03-21 09:44:43 +00:00
|
|
|
dbg_print_(loginfo, img->pos.paper_ind, "genimgobj", chronograph::from_process_born() - bgn, false);
|
2024-02-26 09:25:02 +00:00
|
|
|
|
|
|
|
if(!scan_cntless_ && img->pos.paper_ind == scan_count_)
|
|
|
|
{
|
|
|
|
utils::to_log(LOG_LEVEL_ALL, "Scanning finished for given count %d!\n", scan_count_);
|
|
|
|
break;
|
|
|
|
}
|
2024-03-09 09:47:57 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
devui::send_message(devui::UI_STATUS_PAPER_CNT, (uint8_t*)&pass, sizeof(pass));
|
2024-02-26 09:25:02 +00:00
|
|
|
}
|
|
|
|
|
2024-03-07 08:00:48 +00:00
|
|
|
if(ret || fatal == MOTOR_BORD_EVENT_SCAN_DONE)
|
|
|
|
break;
|
|
|
|
|
2024-03-08 07:04:10 +00:00
|
|
|
if(resok && scanning_)
|
2024-02-26 09:25:02 +00:00
|
|
|
{
|
2024-03-21 09:44:43 +00:00
|
|
|
dbg_print_(loginfo, img->pos.paper_ind, "final", chronograph::from_process_born() - bgn, true);
|
|
|
|
#ifndef REBUILD_IN_CIS_THREAD
|
|
|
|
if(cism_cnt[0] >= camera_->get_mem_count())
|
|
|
|
{
|
|
|
|
ret = SCANNER_ERR_DEVICE_CIS_OUT_OF_MEM;
|
|
|
|
words = ID_WORDS_STATUS_CIS_OUT_OF_MEM;
|
|
|
|
utils::to_log(LOG_LEVEL_FATAL, "Scanning stopped for that V4L2 is out of memory!\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
2024-03-08 07:04:10 +00:00
|
|
|
|
2024-02-26 09:25:02 +00:00
|
|
|
// should check paper ready ?
|
|
|
|
watch.reset();
|
2024-03-21 09:44:43 +00:00
|
|
|
bgn = img->life = chronograph::from_process_born();
|
2024-02-26 09:25:02 +00:00
|
|
|
motor_->pick_paper();
|
2024-03-21 09:44:43 +00:00
|
|
|
|
|
|
|
img_callback(mem, CIS_CB_IMAGE, img);
|
|
|
|
dbg_print_(loginfo, img->pos.paper_ind + 1, "rebuild", chronograph::from_process_born() - bgn, false);
|
|
|
|
mem->release();
|
|
|
|
mem = nullptr;
|
|
|
|
|
|
|
|
retrieve_v4l2_mem(cism, cism_cnt);
|
|
|
|
dbg_print_(loginfo, img->pos.paper_ind + 1, "retrieve_v4l2_mem", chronograph::from_process_born() - bgn, false);
|
|
|
|
|
|
|
|
resok = res_(TASK_CAPTURER, false, 0);
|
|
|
|
dbg_print_(loginfo, img->pos.paper_ind + 1, "chkrsc", chronograph::from_process_born() - bgn, false);
|
2024-02-26 09:25:02 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2024-03-08 07:04:10 +00:00
|
|
|
if(scanning_)
|
|
|
|
utils::to_log(LOG_LEVEL_FATAL, "Resource is up to limit, stop scanning work now!\n");
|
|
|
|
|
2024-02-26 09:25:02 +00:00
|
|
|
ret = SCANNER_ERR_DEVICE_HD_003;
|
|
|
|
words = ID_WORDS_STATUS_DEVICE_HD_003;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-07 08:00:48 +00:00
|
|
|
if(mem)
|
|
|
|
{
|
2024-03-21 09:44:43 +00:00
|
|
|
img_callback(mem, CIS_CB_IMAGE, img);
|
2024-03-07 08:00:48 +00:00
|
|
|
mem->release();
|
|
|
|
mem = nullptr;
|
|
|
|
}
|
|
|
|
|
2024-02-26 09:25:02 +00:00
|
|
|
if(ui_words)
|
|
|
|
*ui_words = words;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2024-01-17 08:54:06 +00:00
|
|
|
int scanner_hw::get_image_real_height(int minh)
|
|
|
|
{
|
|
|
|
chronograph watch;
|
|
|
|
unsigned int h = 0;
|
|
|
|
|
|
|
|
while(h < minh && watch.elapse_ms() < 500)
|
|
|
|
{
|
2024-03-09 09:47:57 +00:00
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
2024-01-17 08:54:06 +00:00
|
|
|
img_controller_->read(14, h);
|
|
|
|
}
|
2024-03-09 09:47:57 +00:00
|
|
|
if(h >= minh)
|
|
|
|
{
|
|
|
|
unsigned int v8 = 0;
|
|
|
|
|
|
|
|
img_controller_->read(8, v8);
|
|
|
|
img_controller_->write(8, v8 & ~8);
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
|
|
|
img_controller_->read(8, v8);
|
|
|
|
img_controller_->write(8, v8 | 8);
|
|
|
|
}
|
|
|
|
// h = img_controller_->get_real_height();
|
2024-01-17 08:54:06 +00:00
|
|
|
|
|
|
|
return h;
|
|
|
|
}
|
2024-01-03 09:39:16 +00:00
|
|
|
void scanner_hw::retrieve_v4l2_mem(safe_fifo<int>* mem, int* used)
|
|
|
|
{
|
|
|
|
int u = *used,
|
|
|
|
ind = 0;
|
|
|
|
|
2024-03-09 09:47:57 +00:00
|
|
|
#ifndef REBUILD_IN_CIS_THREAD
|
2024-02-29 07:45:50 +00:00
|
|
|
while(u >= camera_->get_mem_count() - 2)
|
2024-01-03 09:39:16 +00:00
|
|
|
{
|
|
|
|
if(mem->size())
|
|
|
|
{
|
|
|
|
if(ind)
|
|
|
|
utils::to_log(LOG_LEVEL_WARNING, "V4L2 memory returned.\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if(ind == 0)
|
|
|
|
utils::to_log(LOG_LEVEL_WARNING, "V4L2 is out of memory, wait image processor return ...\n");
|
|
|
|
|
|
|
|
if(ind++ > 1000) // 3 seconds ...
|
|
|
|
break;
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(3));
|
|
|
|
}
|
2024-03-09 09:47:57 +00:00
|
|
|
#endif
|
2024-01-03 09:39:16 +00:00
|
|
|
while(mem->take(ind, false))
|
|
|
|
{
|
|
|
|
u--;
|
|
|
|
camera_->add_v4l2_memory(ind);
|
|
|
|
}
|
|
|
|
*used = u;
|
|
|
|
}
|
2024-01-13 09:14:12 +00:00
|
|
|
void scanner_hw::set_gain_value(bool front, bool gain, int sector, int val)
|
|
|
|
{
|
2024-01-16 09:51:34 +00:00
|
|
|
sector--;
|
2024-01-13 09:14:12 +00:00
|
|
|
if(gain)
|
|
|
|
{
|
|
|
|
if(sector < _countof(gain_[0]))
|
|
|
|
{
|
|
|
|
gain_[!front][sector] = val;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if(sector < _countof(off_[0]))
|
|
|
|
{
|
|
|
|
off_[!front][sector] = val;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-12-19 07:27:16 +00:00
|
|
|
|
|
|
|
// sane_opt_provider
|
|
|
|
char* scanner_hw::get_value(const char* name, void* value, size_t* size, int* err)
|
|
|
|
{
|
|
|
|
char *ret = nullptr;
|
|
|
|
|
2023-12-20 08:44:39 +00:00
|
|
|
if(err)
|
|
|
|
*err = SCANNER_ERR_OK;
|
|
|
|
|
2024-01-31 01:41:22 +00:00
|
|
|
if(strcmp(name, SANE_OPT_NAME(PAPER_ON)) == 0)
|
2023-12-20 08:44:39 +00:00
|
|
|
{
|
2023-12-25 02:08:37 +00:00
|
|
|
ret = (char*)malloc(sizeof(int));
|
|
|
|
*(int*)ret = 0;
|
2023-12-20 08:44:39 +00:00
|
|
|
*(bool*)ret = paper_on_;
|
|
|
|
if(size)
|
|
|
|
*size = sizeof(bool);
|
|
|
|
}
|
2024-01-31 01:41:22 +00:00
|
|
|
else if(strcmp(name, SANE_OPT_NAME(PAPER_W)) == 0)
|
2024-01-11 09:59:23 +00:00
|
|
|
{
|
|
|
|
SIZE sz = paper::size(paper_.c_str());
|
|
|
|
double mm = lateral_ && lateral_en_ ? sz.cy : sz.cx;
|
|
|
|
|
|
|
|
ret = (char*)malloc(sizeof(double));
|
|
|
|
*(double*)ret = mm;
|
|
|
|
if(size)
|
|
|
|
*size = sizeof(double);
|
|
|
|
}
|
2024-01-31 01:41:22 +00:00
|
|
|
else if(strcmp(name, SANE_OPT_NAME(PAPER_H)) == 0)
|
2024-01-11 09:59:23 +00:00
|
|
|
{
|
|
|
|
SIZE sz = paper::size(paper_.c_str());
|
|
|
|
double mm = lateral_ && lateral_en_ ? sz.cx : sz.cy;
|
|
|
|
|
|
|
|
ret = (char*)malloc(sizeof(double));
|
|
|
|
*(double*)ret = mm;
|
|
|
|
if(size)
|
|
|
|
*size = sizeof(double);
|
|
|
|
}
|
2024-01-31 01:41:22 +00:00
|
|
|
else if(strcmp(name, SANE_OPT_NAME(CIS_MODE)) == 0)
|
2024-01-16 09:51:34 +00:00
|
|
|
{
|
|
|
|
ret = (char*)malloc(mode_.length() + 1);
|
|
|
|
strcpy(ret, mode_.c_str());
|
|
|
|
if(size)
|
|
|
|
*size = mode_.length();
|
|
|
|
}
|
2024-01-31 01:41:22 +00:00
|
|
|
else if(strcmp(name, SANE_OPT_NAME(CIS_DPI)) == 0)
|
2024-01-16 09:51:34 +00:00
|
|
|
{
|
|
|
|
ret = (char*)malloc(sizeof(int));
|
|
|
|
*(int*)ret = dpi_;
|
|
|
|
if(size)
|
|
|
|
*size = sizeof(int);
|
|
|
|
}
|
2023-12-20 08:44:39 +00:00
|
|
|
else if(err)
|
|
|
|
*err = SCANNER_ERR_DEVICE_NOT_FOUND;
|
|
|
|
|
2023-12-19 07:27:16 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
int scanner_hw::set_value(const char* name, void* val)
|
|
|
|
{
|
2024-01-02 07:18:42 +00:00
|
|
|
if(scanning_) // working, no set
|
2023-12-29 02:53:04 +00:00
|
|
|
{
|
|
|
|
return SCANNER_ERR_DEVICE_BUSY;
|
|
|
|
}
|
|
|
|
|
2023-12-19 07:27:16 +00:00
|
|
|
if(opt_handler_.count(name))
|
|
|
|
{
|
|
|
|
opt_handler_[name](val);
|
2024-01-13 09:14:12 +00:00
|
|
|
}
|
2024-01-31 01:41:22 +00:00
|
|
|
else if(strstr(name, SANE_OPT_NAME(CIS_GAIN_FRONT)) == name)
|
2024-01-13 09:14:12 +00:00
|
|
|
{
|
2024-01-31 01:41:22 +00:00
|
|
|
name += strlen(SANE_OPT_NAME(CIS_GAIN_FRONT)) + 1;
|
2024-01-13 09:14:12 +00:00
|
|
|
set_gain_value(true, true, atoi(name), *(int*)val);
|
|
|
|
}
|
2024-01-31 01:41:22 +00:00
|
|
|
else if(strstr(name, SANE_OPT_NAME(CIS_GAIN_BACK)) == name)
|
2024-01-13 09:14:12 +00:00
|
|
|
{
|
2024-01-31 01:41:22 +00:00
|
|
|
name += strlen(SANE_OPT_NAME(CIS_GAIN_BACK)) + 1;
|
2024-01-13 09:14:12 +00:00
|
|
|
set_gain_value(false, true, atoi(name), *(int*)val);
|
|
|
|
}
|
2024-01-31 01:41:22 +00:00
|
|
|
else if(strstr(name, SANE_OPT_NAME(CIS_OFFSET_FRONT)) == name)
|
2024-01-13 09:14:12 +00:00
|
|
|
{
|
2024-01-31 01:41:22 +00:00
|
|
|
name += strlen(SANE_OPT_NAME(CIS_OFFSET_FRONT)) + 1;
|
2024-01-13 09:14:12 +00:00
|
|
|
set_gain_value(true, false, atoi(name), *(int*)val);
|
|
|
|
}
|
2024-01-31 01:41:22 +00:00
|
|
|
else if(strstr(name, SANE_OPT_NAME(CIS_OFFSET_BACK)) == name)
|
2024-01-13 09:14:12 +00:00
|
|
|
{
|
2024-01-31 01:41:22 +00:00
|
|
|
name += strlen(SANE_OPT_NAME(CIS_OFFSET_BACK)) + 1;
|
2024-01-13 09:14:12 +00:00
|
|
|
set_gain_value(false, false, atoi(name), *(int*)val);
|
2023-12-19 07:27:16 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
|
|
|
}
|
2024-01-13 09:14:12 +00:00
|
|
|
|
|
|
|
return 0;
|
2023-12-19 07:27:16 +00:00
|
|
|
}
|
2024-01-11 09:59:23 +00:00
|
|
|
void scanner_hw::enable(const char* name, bool able)
|
|
|
|
{
|
2024-01-31 01:41:22 +00:00
|
|
|
if(strcmp(name, SANE_OPT_NAME(LATERAL)) == 0)
|
2024-01-11 09:59:23 +00:00
|
|
|
lateral_en_ = able;
|
|
|
|
}
|
2023-12-19 07:27:16 +00:00
|
|
|
|
|
|
|
// operation ...
|
2024-02-25 05:51:52 +00:00
|
|
|
int scanner_hw::open(std::function<IMAGE_HANDLER_PROTO> image_handler, CHK_RES_FUNC res, std::string* cfgjson, bool count_mode)
|
2023-12-19 07:27:16 +00:00
|
|
|
{
|
2024-01-16 09:51:34 +00:00
|
|
|
std::string tips("");
|
2024-01-23 07:07:17 +00:00
|
|
|
refer_guard<gb_json> cfg(new gb_json());
|
2024-01-16 09:51:34 +00:00
|
|
|
|
2023-12-29 02:53:04 +00:00
|
|
|
this->close();
|
2024-01-11 07:23:05 +00:00
|
|
|
int fh = 16380;
|
2023-12-29 02:53:04 +00:00
|
|
|
|
|
|
|
if(!image_handler)
|
|
|
|
return SCANNER_ERR_INVALID_PARAMETER;
|
|
|
|
|
2024-02-25 05:51:52 +00:00
|
|
|
res_ = res;
|
|
|
|
if(!res_)
|
|
|
|
{
|
|
|
|
DECL_CHK_RES_FUNC(&, r)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
};
|
|
|
|
res_ = r;
|
|
|
|
}
|
|
|
|
|
2024-02-07 04:43:27 +00:00
|
|
|
count_mode_ = count_mode;
|
2023-12-29 02:53:04 +00:00
|
|
|
img_handler_ = image_handler;
|
2024-02-07 04:43:27 +00:00
|
|
|
if(!count_mode_)
|
2024-01-19 08:54:58 +00:00
|
|
|
{
|
2024-02-07 04:43:27 +00:00
|
|
|
img_controller_.reset(new FpgaComm(baud_));
|
|
|
|
if(!img_controller_->is_ok())
|
|
|
|
return DEV_ERR(HD_001);
|
2023-12-19 07:27:16 +00:00
|
|
|
|
2024-02-07 04:43:27 +00:00
|
|
|
img_base_.resolution_x = dpi_;
|
|
|
|
img_base_.resolution_y = dpi_y_;
|
|
|
|
if(mode_ == "\345\275\251\350\211\262")
|
2024-01-16 09:51:34 +00:00
|
|
|
{
|
2024-02-07 04:43:27 +00:00
|
|
|
img_base_.width = cis::get_line_stream_length(dpi_, true);
|
|
|
|
img_controller_->setColorMode(COLOR_MODE);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
img_base_.width = cis::get_line_stream_length(dpi_, false);
|
|
|
|
img_controller_->setColorMode(GRAY_MODE);
|
|
|
|
}
|
|
|
|
img_base_.width *= 2; // two sides
|
|
|
|
|
|
|
|
img_controller_->setDpi(dpi_ == 300 ? DPI_300 : DPI_600);
|
|
|
|
img_controller_->setDelayTime(delay_);
|
|
|
|
img_controller_->setSample(sample_);
|
|
|
|
img_controller_->setSp(sp_);
|
|
|
|
img_controller_->enableLed(cis_led_);
|
|
|
|
img_controller_->setVsp(vsp_a_, vsp_b_);
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "FPGA Sp = %d, Sample = %d\n", sp_, sample_);
|
|
|
|
if(cfgjson)
|
|
|
|
{
|
|
|
|
cfg->set_value("color", mode_.c_str());
|
|
|
|
cfg->set_value("dpi", (std::to_string(dpi_) + " * " + std::to_string(dpi_y_)).c_str());
|
|
|
|
cfg->set_value("sample", sample_);
|
|
|
|
cfg->set_value("Sp", sp_);
|
|
|
|
cfg->set_value("Vsp-A", vsp_a_);
|
|
|
|
cfg->set_value("Vsp-B", vsp_b_);
|
|
|
|
cfg->set_value("Led-On", cis_led_);
|
2024-01-16 09:51:34 +00:00
|
|
|
}
|
2024-01-23 07:07:17 +00:00
|
|
|
|
2024-02-07 04:43:27 +00:00
|
|
|
void(FpgaComm::* exposure[])(int) = {&FpgaComm::setAExposureB, &FpgaComm::setAExposureG
|
|
|
|
, &FpgaComm::setAExposureR, &FpgaComm::setBExposureB, &FpgaComm::setBExposureG, &FpgaComm::setBExposureR};
|
|
|
|
tips = "Exposure(BGR): ";
|
|
|
|
for(int i = 0; i < SIDE_COUNT; ++i)
|
|
|
|
{
|
|
|
|
tips += "\tSide_" + std::to_string(i) + "[";
|
|
|
|
for(int j = 0; j < COLOR_IND_COUNT; ++j)
|
|
|
|
{
|
|
|
|
(img_controller_.get()->*exposure[i * SIDE_COUNT + j])(exposure_[i][j]);
|
|
|
|
tips += std::to_string(exposure_[i][j]) + ", ";
|
|
|
|
}
|
|
|
|
tips.erase(tips.length() - 2);
|
|
|
|
tips += "];";
|
|
|
|
}
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "%s\n", tips.c_str());
|
|
|
|
if(cfgjson)
|
|
|
|
{
|
|
|
|
char val[128] = {0};
|
2024-01-23 07:07:17 +00:00
|
|
|
|
2024-02-07 04:43:27 +00:00
|
|
|
sprintf(val, "(%u, %u, %u)", exposure_[SIDE_FRONT][COLOR_IND_RED], exposure_[SIDE_FRONT][COLOR_IND_GREEN], exposure_[SIDE_FRONT][COLOR_IND_BLUE]);
|
|
|
|
cfg->set_value("exposure-A(RGB)", val);
|
|
|
|
|
|
|
|
sprintf(val, "(%u, %u, %u)", exposure_[SIDE_BACK][COLOR_IND_RED], exposure_[SIDE_BACK][COLOR_IND_GREEN], exposure_[SIDE_BACK][COLOR_IND_BLUE]);
|
|
|
|
cfg->set_value("exposure-B(RGB)", val);
|
|
|
|
}
|
2023-12-19 07:27:16 +00:00
|
|
|
|
2024-01-23 07:07:17 +00:00
|
|
|
for(int i = 0; i < CIS_SECTOR_COUNT; ++i)
|
|
|
|
{
|
2024-02-07 04:43:27 +00:00
|
|
|
tips = "Gain: Sector_" + std::to_string(i + 1) + "[F=";
|
|
|
|
tips += std::to_string(gain_[SIDE_FRONT][i]) + "x + " + std::to_string(off_[SIDE_FRONT][i]) + "];\t[B="
|
|
|
|
+ std::to_string(gain_[SIDE_BACK][i]) + "x + " + std::to_string(off_[SIDE_BACK][i]) + "]";
|
|
|
|
img_controller_->setAGain(i, gain_[SIDE_FRONT][i]);
|
|
|
|
img_controller_->setBGain(i, gain_[SIDE_BACK][i]);
|
|
|
|
img_controller_->setAOffset(i, off_[SIDE_FRONT][i]);
|
|
|
|
img_controller_->setBOffset(i, off_[SIDE_BACK][i]);
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "%s\n", tips.c_str());
|
|
|
|
}
|
|
|
|
if(cfgjson)
|
|
|
|
{
|
|
|
|
for(int i = 0; i < CIS_SECTOR_COUNT; ++i)
|
|
|
|
{
|
|
|
|
char key[40] = {0}, val[128] = {0};
|
2024-01-23 07:07:17 +00:00
|
|
|
|
2024-02-07 04:43:27 +00:00
|
|
|
sprintf(key, "gain-sec-%d", i + 1);
|
|
|
|
sprintf(val, "A = %ux + %u, B = %ux + %u"
|
|
|
|
, gain_[SIDE_FRONT][i], off_[SIDE_FRONT][i]
|
|
|
|
, gain_[SIDE_BACK][i], off_[SIDE_BACK][i]);
|
|
|
|
cfg->set_value(key, val);
|
|
|
|
}
|
2024-01-23 07:07:17 +00:00
|
|
|
}
|
|
|
|
}
|
2023-12-19 07:27:16 +00:00
|
|
|
|
2024-01-09 07:32:03 +00:00
|
|
|
auto cb = [this](int ev, unsigned int data) -> void
|
|
|
|
{
|
2024-02-28 02:28:42 +00:00
|
|
|
printf("motorboard event: 0x%08X, data = %d\n", ev, data);
|
2024-01-09 07:32:03 +00:00
|
|
|
mb_events_.save(std::make_pair(ev, data), true);
|
|
|
|
};
|
|
|
|
mb_events_.clear();
|
2024-03-07 08:00:48 +00:00
|
|
|
motor_.reset(new MotorBoard(/*cb*/));
|
2023-12-20 08:44:39 +00:00
|
|
|
motor_->set_double_inpect(double_chk_);
|
|
|
|
motor_->set_staple_inpect(staple_chk_);
|
|
|
|
motor_->set_screw_inpect(screw_chk_);
|
2023-12-29 02:53:04 +00:00
|
|
|
motor_->set_screw_level(screw_chk_level_);
|
2024-03-01 09:16:12 +00:00
|
|
|
motor_->set_slowmoire(false);
|
|
|
|
if(1 || count_mode_)
|
|
|
|
motor_->set_speed_mode(SPEED_PPM_BASE_20);
|
|
|
|
else
|
|
|
|
motor_->set_speed_mode(motor_speed_);
|
2024-01-09 06:26:46 +00:00
|
|
|
motor_->set_auto_paper(auto_scan_, true);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
2023-12-29 02:53:04 +00:00
|
|
|
unsigned int val = 0;
|
2024-01-09 06:26:46 +00:00
|
|
|
if(motor_->read(MB_PORT_CONFIG, val))
|
2023-12-29 02:53:04 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "MotorBoard config : %p\n", val);
|
|
|
|
else
|
|
|
|
utils::to_log(LOG_LEVEL_FATAL, "Get motor-board config failed.\n");
|
2024-01-09 06:26:46 +00:00
|
|
|
if(motor_->read(MB_PORT_STATUS, val))
|
2023-12-29 02:53:04 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "MotorBoard status : %p\n", val);
|
|
|
|
else
|
|
|
|
utils::to_log(LOG_LEVEL_FATAL, "Get motor-board status failed.\n");
|
2024-01-09 06:26:46 +00:00
|
|
|
if(motor_->read(MB_PORT_MODE, val))
|
2023-12-29 02:53:04 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "MotorBoard mode : %p\n", val);
|
|
|
|
else
|
|
|
|
utils::to_log(LOG_LEVEL_FATAL, "Get motor-board mode failed.\n");
|
2024-01-09 06:26:46 +00:00
|
|
|
if(motor_->read(MB_PORT_VERSION, val))
|
2023-12-29 02:53:04 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "MotorBoard version: %p\n", val);
|
|
|
|
else
|
|
|
|
utils::to_log(LOG_LEVEL_FATAL, "Get motor-board version failed.\n");
|
2024-01-09 06:26:46 +00:00
|
|
|
if(motor_->read(MB_PORT_CONFIG_EX, val))
|
2023-12-29 02:53:04 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "MotorBoard confige: %p\n", val);
|
|
|
|
else
|
|
|
|
utils::to_log(LOG_LEVEL_FATAL, "Get motor-board confige failed.\n");
|
|
|
|
|
2024-02-07 04:43:27 +00:00
|
|
|
if(!count_mode_)
|
|
|
|
{
|
|
|
|
camera_.reset(new GVideoISP1());
|
|
|
|
camera_->open(/*3888*/cis::get_sector_pixels(0, dpi_, true) * CIS_SECTOR_COUNT, fh);
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(20));
|
|
|
|
|
|
|
|
img_controller_->setFrameHeight(frame_h_);
|
|
|
|
img_controller_->capture();
|
|
|
|
size_t size;
|
|
|
|
int _int;
|
|
|
|
auto data = camera_->read_frame(100, size, _int);
|
|
|
|
if(data)
|
|
|
|
camera_->add_v4l2_memory(_int);
|
|
|
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(20));
|
|
|
|
img_controller_->setFrameHeight(fh / 2 * 3);
|
|
|
|
// if(1)
|
|
|
|
// {
|
|
|
|
// // debug ...
|
|
|
|
// unsigned int vals[] = {0x5ffa, 0x3300c9d, 0x1, 0xaa00aa, 0x340030aa, 0x1380193
|
|
|
|
// , 0x1270131, 0x340030aa, 0x168000c, 0x168017b, 0, 0x0afa3f
|
|
|
|
// , 0x3e8};
|
|
|
|
// for(int i = 0; i < _countof(vals); ++i)
|
|
|
|
// img_controller_->write(i, vals[i]);
|
|
|
|
// }
|
|
|
|
|
|
|
|
std::vector<int> regs;
|
|
|
|
img_controller_->update(®s);
|
|
|
|
if(cfgjson)
|
|
|
|
{
|
|
|
|
gb_json *c = new gb_json();
|
|
|
|
c->clear(true);
|
|
|
|
for(auto& v: regs)
|
|
|
|
*c += v;
|
|
|
|
cfg->set_value("controller", c);
|
|
|
|
c->release();
|
|
|
|
*cfgjson = std::move(cfg->to_string());
|
|
|
|
}
|
2024-01-23 07:07:17 +00:00
|
|
|
}
|
2024-01-11 07:23:05 +00:00
|
|
|
|
2024-03-21 09:44:43 +00:00
|
|
|
auto empty_log = [this](LOG_CIS_TIME_PROTO) -> void
|
|
|
|
{
|
|
|
|
|
|
|
|
};
|
|
|
|
auto real_log = [this](LOG_CIS_TIME_PROTO) -> void
|
|
|
|
{
|
|
|
|
if(log.empty())
|
|
|
|
log = "Paper " + std::to_string(paper) + " - ";
|
|
|
|
else
|
|
|
|
log += " -> ";
|
|
|
|
log += std::to_string(ms) + "ms(" + step + ")";
|
|
|
|
|
|
|
|
if(last)
|
|
|
|
{
|
|
|
|
size_t len = sizeof(PACK_BASE) + log.length() + 1;
|
|
|
|
dyn_mem_ptr ptr = dyn_mem::memory(len);
|
|
|
|
LPPACK_BASE pck = (LPPACK_BASE)ptr->ptr();
|
|
|
|
|
|
|
|
BASE_PACKET_REPLY(*pck, PACK_CMD_DEBUG_INFO, 0, 0);
|
|
|
|
strcpy(pck->payload, log.c_str());
|
|
|
|
pck->payload[log.length()] = 0;
|
|
|
|
pck->payload_len = log.length() + 1;
|
|
|
|
ptr->set_len(len);
|
|
|
|
img_handler_(ptr, CIS_CB_STATUS, nullptr);
|
|
|
|
ptr->release();
|
|
|
|
log = "";
|
|
|
|
}
|
|
|
|
};
|
|
|
|
if(log_debug_info_)
|
|
|
|
dbg_print_ = real_log;
|
|
|
|
else
|
|
|
|
dbg_print_ = empty_log;
|
|
|
|
|
2023-12-29 02:53:04 +00:00
|
|
|
return SCANNER_ERR_OK;
|
2023-12-19 07:27:16 +00:00
|
|
|
}
|
|
|
|
int scanner_hw::start_scan(void)
|
|
|
|
{
|
2024-01-03 09:39:16 +00:00
|
|
|
unsigned int val = 0;
|
|
|
|
|
2024-02-07 04:43:27 +00:00
|
|
|
if(!motor_.get() || (!count_mode_ && (!camera_.get() || !img_controller_.get())))
|
2024-01-03 09:39:16 +00:00
|
|
|
return DEV_ERR(NOT_READY);
|
2023-12-26 01:33:05 +00:00
|
|
|
|
2023-12-29 02:53:04 +00:00
|
|
|
motor_->clear_error();
|
2024-01-09 06:26:46 +00:00
|
|
|
if(!motor_->read(MB_PORT_STATUS, val))
|
2024-01-03 09:39:16 +00:00
|
|
|
return DEV_ERR(GET_STATUS_FAILED);
|
|
|
|
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "start scan: status = 0x%08x.\n", val);
|
|
|
|
if (((SMBSTATUS*)&val)->open_machine) // 0x700fe
|
2024-02-20 03:29:26 +00:00
|
|
|
{
|
|
|
|
devui::send_status_message(ID_WORDS_STATUS_COVER_OPEN);
|
|
|
|
|
2024-01-03 09:39:16 +00:00
|
|
|
return DEV_ERR(COVER_OPENNED);
|
2024-02-20 03:29:26 +00:00
|
|
|
}
|
2024-01-03 09:39:16 +00:00
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
if(!motor_->read(MB_PORT_MODE, val))
|
2024-01-03 09:39:16 +00:00
|
|
|
return DEV_ERR(GET_STATUS_FAILED);
|
|
|
|
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "start scan: mode-status = 0x%08x.\n", val);
|
2024-01-05 09:36:50 +00:00
|
|
|
if(((SMBMODE*)&val)->paper_jammed_in ||
|
|
|
|
((SMBMODE*)&val)->paper_jammed_out)
|
2024-02-20 03:29:26 +00:00
|
|
|
{
|
|
|
|
devui::send_status_message(ID_WORDS_STATUS_JAMMED);
|
|
|
|
|
2024-01-03 09:39:16 +00:00
|
|
|
return DEV_ERR(PAPER_JAMMED);
|
2024-02-20 03:29:26 +00:00
|
|
|
}
|
2024-01-03 09:39:16 +00:00
|
|
|
|
2024-02-07 08:26:23 +00:00
|
|
|
bool paperok = ((SMBMODE*)&val)->feeding_paper_ready;
|
|
|
|
if(!paperok && !auto_scan_)
|
2024-02-20 03:29:26 +00:00
|
|
|
{
|
|
|
|
devui::send_status_message(ID_WORDS_STATUS_NO_PAPER);
|
|
|
|
|
2024-01-03 09:39:16 +00:00
|
|
|
return DEV_ERR(NO_PAPER);
|
2024-02-20 03:29:26 +00:00
|
|
|
}
|
2024-01-02 07:18:42 +00:00
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
scanning_ = true;
|
2024-01-11 07:23:05 +00:00
|
|
|
mb_events_.clear();
|
2024-02-07 08:26:23 +00:00
|
|
|
scan_thread_.reset(new std::thread(&scanner_hw::thread_image_capture, this, paperok));
|
2023-12-20 07:23:24 +00:00
|
|
|
|
2024-01-02 07:18:42 +00:00
|
|
|
return SCANNER_ERR_OK;
|
2023-12-19 07:27:16 +00:00
|
|
|
}
|
2024-02-21 03:10:14 +00:00
|
|
|
int scanner_hw::stop_scan(bool from_ui)
|
2023-12-19 07:27:16 +00:00
|
|
|
{
|
2024-02-21 02:44:40 +00:00
|
|
|
bool working = scanning_;
|
|
|
|
|
2024-02-07 04:43:27 +00:00
|
|
|
scanning_ = auto_scan_ = false;
|
|
|
|
mb_events_.trigger();
|
2023-12-29 02:53:04 +00:00
|
|
|
if(motor_.get())
|
2024-01-02 07:18:42 +00:00
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
motor_->set_auto_paper(false, false);
|
2023-12-29 02:53:04 +00:00
|
|
|
motor_->stop();
|
2024-01-02 07:18:42 +00:00
|
|
|
}
|
2023-12-29 02:53:04 +00:00
|
|
|
|
2024-01-19 08:54:58 +00:00
|
|
|
// if(camera_.get())
|
|
|
|
// camera_->stop();
|
|
|
|
// mb_events_.clear();
|
2023-12-20 07:23:24 +00:00
|
|
|
|
2024-02-21 03:10:14 +00:00
|
|
|
if(!working && from_ui)
|
2024-02-21 02:44:40 +00:00
|
|
|
{
|
|
|
|
devui::SCANSTREAM stream;
|
|
|
|
stream.err = 0;
|
|
|
|
stream.mode = devui::SCAN_STOPPED;
|
|
|
|
stream.speed = 0;
|
|
|
|
|
|
|
|
devui::send_message(devui::UI_STATUS_SCANNING, (uint8_t*)&stream, sizeof(stream));
|
|
|
|
}
|
|
|
|
|
2023-12-19 07:27:16 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2024-01-19 08:54:58 +00:00
|
|
|
int scanner_hw::close(bool from_worker)
|
2023-12-19 07:27:16 +00:00
|
|
|
{
|
2023-12-29 02:53:04 +00:00
|
|
|
img_controller_.reset();
|
|
|
|
if(motor_.get())
|
2023-12-19 07:27:16 +00:00
|
|
|
{
|
2023-12-29 02:53:04 +00:00
|
|
|
motor_->stop();
|
|
|
|
motor_.reset();
|
|
|
|
}
|
|
|
|
if(camera_.get())
|
|
|
|
{
|
|
|
|
camera_->stop();
|
|
|
|
camera_->close();
|
|
|
|
camera_.reset();
|
2023-12-19 07:27:16 +00:00
|
|
|
}
|
2024-01-19 08:54:58 +00:00
|
|
|
if(!from_worker)
|
|
|
|
{
|
|
|
|
if(scan_thread_.get() && scan_thread_->joinable())
|
|
|
|
scan_thread_->join();
|
|
|
|
scan_thread_.reset();
|
|
|
|
}
|
2023-12-19 07:27:16 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2024-02-26 09:25:02 +00:00
|
|
|
int scanner_hw::trans_motorboard_err_2_hg_error(int mberr, int *ui_msg)
|
2024-01-27 09:43:13 +00:00
|
|
|
{
|
|
|
|
unsigned int val = mberr;
|
2024-02-21 02:44:40 +00:00
|
|
|
SMBSTATUS *s = (SMBSTATUS*)&val;
|
|
|
|
int msg = 0;
|
|
|
|
|
2024-01-27 09:43:13 +00:00
|
|
|
if(s->open_machine)
|
2024-02-21 02:44:40 +00:00
|
|
|
{
|
2024-01-27 09:43:13 +00:00
|
|
|
mberr = SCANNER_ERR_DEVICE_COVER_OPENNED;
|
2024-02-21 02:44:40 +00:00
|
|
|
msg = ID_WORDS_STATUS_COVER_OPEN;
|
|
|
|
}
|
2024-01-27 09:43:13 +00:00
|
|
|
else if(s->pick_failed)
|
2024-02-21 02:44:40 +00:00
|
|
|
{
|
2024-01-27 09:43:13 +00:00
|
|
|
mberr = SCANNER_ERR_DEVICE_FEEDING_PAPER;
|
2024-02-21 02:44:40 +00:00
|
|
|
msg = ID_WORDS_STATUS_FEED_ERR;
|
|
|
|
}
|
2024-01-27 09:43:13 +00:00
|
|
|
else if(s->double_paper)
|
2024-02-21 02:44:40 +00:00
|
|
|
{
|
2024-01-27 09:43:13 +00:00
|
|
|
mberr = SCANNER_ERR_DEVICE_DOUBLE_FEEDING;
|
2024-02-21 02:44:40 +00:00
|
|
|
msg = ID_WORDS_STATUS_DOUBLE_FEED;
|
|
|
|
}
|
2024-01-27 09:43:13 +00:00
|
|
|
else if(s->staple)
|
2024-02-21 02:44:40 +00:00
|
|
|
{
|
2024-01-27 09:43:13 +00:00
|
|
|
mberr = SCANNER_ERR_DEVICE_STAPLE_ON;
|
2024-02-21 02:44:40 +00:00
|
|
|
msg = ID_WORDS_STATUS_STAPLE;
|
|
|
|
}
|
2024-01-27 09:43:13 +00:00
|
|
|
else if(s->papertilted)
|
2024-02-21 02:44:40 +00:00
|
|
|
{
|
2024-01-27 09:43:13 +00:00
|
|
|
mberr = SCANNER_ERR_DEVICE_PAPER_SKEW;
|
2024-02-21 02:44:40 +00:00
|
|
|
msg = ID_WORDS_STATUS_ASKEW;
|
|
|
|
}
|
|
|
|
|
2024-02-26 09:25:02 +00:00
|
|
|
if(ui_msg)
|
|
|
|
*ui_msg = msg;
|
2024-01-27 09:43:13 +00:00
|
|
|
|
|
|
|
return mberr;
|
|
|
|
}
|
|
|
|
int scanner_hw::hg_err_2_image_status(int hgerr)
|
|
|
|
{
|
|
|
|
if(hgerr == SCANNER_ERR_DEVICE_DOUBLE_FEEDING)
|
|
|
|
return IMG_STATUS_DOUBLE;
|
|
|
|
if(hgerr == SCANNER_ERR_DEVICE_PAPER_JAMMED)
|
|
|
|
return IMG_STATUS_JAM;
|
|
|
|
if(hgerr == SCANNER_ERR_DEVICE_STAPLE_ON)
|
|
|
|
return IMG_STATUS_STAPLE;
|
|
|
|
|
|
|
|
return IMG_STATUS_OK;
|
|
|
|
}
|
2024-01-05 09:36:50 +00:00
|
|
|
bool scanner_hw::is_scanning(void)
|
|
|
|
{
|
|
|
|
return scanning_;
|
2024-02-07 08:26:23 +00:00
|
|
|
}
|
2024-02-23 07:59:31 +00:00
|
|
|
void scanner_hw::clean_paper_passway(void)
|
|
|
|
{
|
|
|
|
if(!motor_.get())
|
|
|
|
{
|
|
|
|
auto cb = [this](int ev, unsigned int data) -> void
|
|
|
|
{
|
|
|
|
mb_events_.save(std::make_pair(ev, data), true);
|
|
|
|
};
|
|
|
|
mb_events_.clear();
|
|
|
|
motor_.reset(new MotorBoard(cb));
|
|
|
|
}
|
|
|
|
|
|
|
|
motor_->clean_paper_road();
|
|
|
|
}
|
|
|
|
|