2023-12-20 07:23:24 +00:00
|
|
|
|
#include "motorboard.h"
|
|
|
|
|
|
|
|
|
|
#include <iostream>
|
2024-02-02 08:53:17 +00:00
|
|
|
|
#include <uart/PinMonitor.h>
|
2023-12-20 07:23:24 +00:00
|
|
|
|
#include "../uart/uartregsaccess.h"
|
|
|
|
|
#include <iomanip>
|
2024-01-09 06:26:46 +00:00
|
|
|
|
#include <bitset>
|
2023-12-20 07:23:24 +00:00
|
|
|
|
|
|
|
|
|
#include <base/utils.h>
|
2024-01-09 06:26:46 +00:00
|
|
|
|
#include <base/ui.h>
|
2024-03-07 08:00:48 +00:00
|
|
|
|
#include <huagao/hgscanner_error.h>
|
|
|
|
|
#include <base/words.h>
|
2023-12-20 07:23:24 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define MOTOR_UART "/dev/ttyS4"
|
|
|
|
|
static const std::string loggername = "MotorBoard";
|
|
|
|
|
|
|
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
|
MotorBoard::MotorBoard(std::function<void(int, unsigned int)> evcb)
|
|
|
|
|
: devPort(MOTOR_UART), event_cb_(evcb)
|
2024-03-09 07:38:23 +00:00
|
|
|
|
, autopaperkeystop(nullptr), mb_events_("motor-events")
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// LOG_INIT();
|
|
|
|
|
//m_uartEnable.reset(new GpioOut(149));
|
2023-12-20 07:23:24 +00:00
|
|
|
|
//m_uartEnable->setValue(Gpio::Low);
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
|
|
|
|
m_regsAccess.reset(new UartRegsAccess(devPort, bauds, 0x07, 0x87));
|
2024-03-09 07:38:23 +00:00
|
|
|
|
m_intPinMonitor.reset(new PinMonitor(intport, std::bind(&MotorBoard::pin_call, this, std::placeholders::_1)));
|
2023-12-20 07:23:24 +00:00
|
|
|
|
//m_uartEnable->setValue(Gpio::High);
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
|
|
|
|
m_os_mode = os_mode();
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// m_statecontrol.reset(new StateControl(m_regsAccess,wake));
|
|
|
|
|
init_sensor_duty();
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
|
|
2023-12-20 07:23:24 +00:00
|
|
|
|
static int paperinnum = 0;
|
2024-01-09 06:26:46 +00:00
|
|
|
|
void MotorBoard::start(void)
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
|
|
|
|
keep_last_paper=false;
|
2024-01-09 06:26:46 +00:00
|
|
|
|
paperinnum = 0;
|
|
|
|
|
m_paperout_count = 0;
|
|
|
|
|
clear_error();
|
|
|
|
|
set_time_error(120);
|
|
|
|
|
// set_double_inpect(m_config.g200params.double_feed_enbale);
|
|
|
|
|
// set_staple_inpect(m_config.g200params.stable_enbale);
|
|
|
|
|
// set_paper_inspect(0);
|
|
|
|
|
// set_auto_paper(m_config.g200params.is_autopaper,m_config.g200params.en_anlogic_key);
|
|
|
|
|
// set_screw_inpect(m_config.g200params.screw_detect_enable);
|
|
|
|
|
// set_screw_level(m_config.g200params.screw_detect_level);
|
|
|
|
|
// set_long_paper(true);
|
|
|
|
|
// set_double_out_en(m_config.g200params.double_out_en);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
unsigned int val;
|
|
|
|
|
SMBCONFIG *smbc = (SMBCONFIG *)(&val);
|
|
|
|
|
read(0, val);
|
|
|
|
|
smbc->enable = 0;
|
|
|
|
|
write(0, val);
|
|
|
|
|
smbc->enable = 1;
|
|
|
|
|
write(0, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
|
|
|
|
|
en_lifter();
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void MotorBoard::stop()
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
|
|
|
|
SMBCONFIG *smbc = (SMBCONFIG *)(&val);
|
2024-01-19 08:54:58 +00:00
|
|
|
|
SMBSTATUS *status = (SMBSTATUS*)&val;
|
|
|
|
|
|
|
|
|
|
if(this->read(MB_PORT_STATUS, val))
|
|
|
|
|
{
|
|
|
|
|
if(!status->scan_pulse)
|
|
|
|
|
{
|
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "ignore 'MotorBoard::stop' command for device is not in working(0x%08x).\n", val);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
printf("MotorBoard Stop \n");
|
2023-12-20 07:23:24 +00:00
|
|
|
|
read(0, val);
|
|
|
|
|
smbc->enable = 0;
|
|
|
|
|
write(0, val);
|
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
|
bool MotorBoard::en_lifter()
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
|
|
|
|
SMBCONFIG *smbc = (SMBCONFIG *)(&val);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
read(MB_PORT_CONFIG, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
smbc->lifter_en = 1;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_CONFIG, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
smbc->lifter_en = 0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
2023-12-20 07:23:24 +00:00
|
|
|
|
|
|
|
|
|
void MotorBoard::pick_paper(void)
|
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
unsigned int val,pick_en;
|
2023-12-20 07:23:24 +00:00
|
|
|
|
SMBCONFIG *smbc = (SMBCONFIG *)(&val);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
read(MB_PORT_CONFIG, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
smbc->pick_paper = 0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_CONFIG, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
std::this_thread::sleep_for(std::chrono::microseconds(400));
|
2023-12-20 07:23:24 +00:00
|
|
|
|
smbc->pick_paper = 1;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_CONFIG, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
std::string v_str = std::to_string(m_version);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
// if(v_str.size()<8)
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return;
|
|
|
|
|
uint32_t date = atoi(v_str.substr(2,6).c_str());
|
|
|
|
|
#ifdef G100
|
|
|
|
|
if(date < 231115)
|
|
|
|
|
return;
|
|
|
|
|
#else
|
|
|
|
|
if(date < 231122)
|
|
|
|
|
return;
|
|
|
|
|
#endif
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
|
|
|
|
read(0x09,pick_en);
|
|
|
|
|
if(!(pick_en&0xffff))
|
|
|
|
|
{
|
|
|
|
|
smbc->pick_paper = 0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_CONFIG, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
std::this_thread::sleep_for(std::chrono::microseconds(400));
|
|
|
|
|
smbc->pick_paper = 1;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_CONFIG, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
2023-12-20 07:23:24 +00:00
|
|
|
|
// smbc->pick_paper = 0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
// write(MB_PORT_CONFIG, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void MotorBoard::clean_paper_road(){
|
|
|
|
|
unsigned int val;
|
|
|
|
|
SMB_FUNC *smbc = (SMB_FUNC *)(&val);
|
|
|
|
|
read(6, val);
|
|
|
|
|
if(smbc->param.work_mode == 0)
|
|
|
|
|
{
|
|
|
|
|
smbc->param.func_clean_passthro = 1;
|
|
|
|
|
write(6, val);
|
|
|
|
|
smbc->param.func_clean_passthro = 0;
|
|
|
|
|
write(6, val);
|
|
|
|
|
}
|
|
|
|
|
else{
|
|
|
|
|
printf("\n 非空闲模式不允许清理纸道!!!!");
|
|
|
|
|
}
|
|
|
|
|
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void MotorBoard::clear_error()
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
|
|
|
|
SMBCONFIG *smbc = (SMBCONFIG *)(&val);
|
|
|
|
|
read(0, val);
|
|
|
|
|
smbc->error_clean = 1;
|
|
|
|
|
write(0, val);
|
|
|
|
|
smbc->error_clean = 0;
|
|
|
|
|
write(0, val);
|
2024-03-09 07:38:23 +00:00
|
|
|
|
|
|
|
|
|
mb_events_.clear();
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
|
bool MotorBoard::wait_arrival_top(int timeout_ms)
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return cv_arrival_top.wait(timeout_ms);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
|
bool MotorBoard::wait_paper_in(int timeout_ms)
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return cv_paper_in.wait(timeout_ms);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::wait_error(int timeout_ms)
|
|
|
|
|
{
|
|
|
|
|
return cv_error.wait(timeout_ms);
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
|
bool MotorBoard::wait_paper_out(int timeout_ms)
|
|
|
|
|
{
|
|
|
|
|
// StopWatch sw;
|
|
|
|
|
// LOG_TRACE("wait_paper_out ");
|
|
|
|
|
// while(sw.elapsed_ms()<timeout_ms)
|
|
|
|
|
// {
|
|
|
|
|
// if(m_paperout_count > 0)
|
|
|
|
|
// {
|
|
|
|
|
// m_paperout_count--;
|
|
|
|
|
// return true;
|
|
|
|
|
// }
|
|
|
|
|
// std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
|
|
|
|
// }
|
|
|
|
|
// return false;
|
|
|
|
|
return cv_paper_out.wait(timeout_ms);
|
|
|
|
|
}
|
|
|
|
|
|
2023-12-20 07:23:24 +00:00
|
|
|
|
bool MotorBoard::wait_done(int timeout_ms)
|
|
|
|
|
{
|
|
|
|
|
return cv_scan_done.wait(timeout_ms);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int MotorBoard::os_mode()
|
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
// read(MB_PORT_MODE, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// SMB_MODE *smb_mode = (SMB_MODE *)&val;
|
|
|
|
|
// return smb_mode->scan_mode;
|
2023-12-20 07:23:24 +00:00
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
read(MB_PORT_FUNCTION,val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
SMB_FUNC smb_func = *(SMB_FUNC*)&val;
|
|
|
|
|
return smb_func.param.work_mode == 1;
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::paper_ready()
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
read(MB_PORT_MODE, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
SMB_MODE *smb_mode = (SMB_MODE *)&val;
|
|
|
|
|
return smb_mode->feeding_paper_ready;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::is_scanning()
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
read(MB_PORT_MODE, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
SMB_MODE *smb_mode = (SMB_MODE *)&val;
|
|
|
|
|
return smb_mode->work_status;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int MotorBoard::paper_counter()
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
read(MB_PORT_MODE, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
SMBMODE *smb_mode = (SMBMODE *)&val;
|
|
|
|
|
return smb_mode->scan_num;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::set_paper_inspect_param(unsigned int value /* = 1000 */)
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG_EX, val))
|
2023-12-20 07:23:24 +00:00
|
|
|
|
return false;
|
|
|
|
|
SMBCONFIGEXT *smb_config_ext = (SMBCONFIGEXT *)&val;
|
|
|
|
|
smb_config_ext->error_range_set = value;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG_EX, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::get_keeplastpaper(){
|
|
|
|
|
return keep_last_paper;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::set_paper_inpect_info(unsigned int value)
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG_EX, val))
|
2023-12-20 07:23:24 +00:00
|
|
|
|
return false;
|
|
|
|
|
SMBCONFIGEXT *smb_config_ext = (SMBCONFIGEXT *)&val;
|
|
|
|
|
smb_config_ext->paper_infor = value;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG_EX, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::set_paper_inspect(bool enable /* = true */)
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG_EX, val))
|
2023-12-20 07:23:24 +00:00
|
|
|
|
return false;
|
|
|
|
|
SMBCONFIGEXT *smb_config_ext = (SMBCONFIGEXT *)&val;
|
|
|
|
|
smb_config_ext->paper_size_check_en = enable;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG_EX, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::set_double_inpect(bool enable)
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG, val))
|
2023-12-20 07:23:24 +00:00
|
|
|
|
return false;
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// enable?m_statecontrol->lcdcontrol(4):m_statecontrol->lcdcontrol(5);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
SMBCONFIG *smb_config = (SMBCONFIG *)&val;
|
|
|
|
|
smb_config->double_paper = enable;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
bool MotorBoard::get_doublle_inpect()
|
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return 0;
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
|
bool MotorBoard::set_double_out_en(bool enable)
|
|
|
|
|
{
|
2023-12-20 07:23:24 +00:00
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG, val))
|
2023-12-20 07:23:24 +00:00
|
|
|
|
return false;
|
|
|
|
|
SMBCONFIG *smb_config = (SMBCONFIG *)&val;
|
2024-01-09 06:26:46 +00:00
|
|
|
|
smb_config->double_out_en = enable;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
bool MotorBoard::get_double_out_en()
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG, val))
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return false;
|
|
|
|
|
SMBCONFIG *smb_config = (SMBCONFIG *)&val;
|
|
|
|
|
return smb_config->double_out_en;
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
bool MotorBoard::set_staple_inpect(bool enable)
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG, val))
|
2023-12-20 07:23:24 +00:00
|
|
|
|
return false;
|
|
|
|
|
SMBCONFIG *smb_config = (SMBCONFIG *)&val;
|
|
|
|
|
smb_config->staple_enable = enable;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
bool MotorBoard::get_staple_inpect()
|
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return 0;
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
|
|
|
|
|
|
bool MotorBoard::set_cuospeed(int value)
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
|
|
|
|
if (!read(0x4, val))
|
|
|
|
|
return false;
|
|
|
|
|
SMBCONFIGEXT *smb_config = (SMBCONFIGEXT *)&val;
|
|
|
|
|
smb_config->cuo_speed = value;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG_EX, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// bool MotorBoard::set_en600DPI(bool en)
|
|
|
|
|
// {
|
|
|
|
|
// unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
// if (!read(MB_PORT_CONFIG, val))
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// return false;
|
|
|
|
|
// SMBCONFIG *smb_config = (SMBCONFIG *)&val;
|
|
|
|
|
// smb_config->dpi600 = en?1:0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
// return write(MB_PORT_CONFIG, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// }
|
2023-12-20 07:23:24 +00:00
|
|
|
|
bool MotorBoard::set_color_mode(int mode)
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG, val))
|
2023-12-20 07:23:24 +00:00
|
|
|
|
return false;
|
|
|
|
|
SMBCONFIG *smb_config = (SMBCONFIG *)&val;
|
|
|
|
|
smb_config->color_mode = mode;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::set_slowmoire(bool en){
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG, val))
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return false;
|
|
|
|
|
SMBCONFIG *smb_config = (SMBCONFIG *)&val;
|
|
|
|
|
smb_config->slow_moire = en;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
|
|
|
|
|
|
|
2023-12-20 07:23:24 +00:00
|
|
|
|
int MotorBoard::get_color_mode()
|
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return 0;
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::set_speed_mode(int mode)
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG, val))
|
2023-12-20 07:23:24 +00:00
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
SMBCONFIG *smb_config = (SMBCONFIG *)&val;
|
|
|
|
|
smb_config->speed_set_enable = 1;
|
|
|
|
|
smb_config->v_setting = mode;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_CONFIG, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
smb_config->speed_set_enable = 0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
|
bool MotorBoard::set_speed_mode_v_temp(int mode)
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG, val))
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return false;
|
|
|
|
|
printf(" set v_tmp = %d \n",mode);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
SMBCONFIG *smb_config = (SMBCONFIG *)&val;
|
2024-01-09 06:26:46 +00:00
|
|
|
|
smb_config->speed_set_enable = 1;
|
|
|
|
|
smb_config->v_temp = mode;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_CONFIG, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
smb_config->speed_set_enable = 0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
|
int MotorBoard::get_speed_mode()
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG, val))
|
2023-12-20 07:23:24 +00:00
|
|
|
|
return -1;
|
2024-01-09 06:26:46 +00:00
|
|
|
|
SMBCONFIG *smb_config = (SMBCONFIG *)&val;
|
|
|
|
|
return smb_config->v_setting;
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::shared_ptr<IRegsAccess> MotorBoard::regs()
|
|
|
|
|
{
|
|
|
|
|
return m_regsAccess;
|
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
|
static int countindex =0;
|
2023-12-20 07:23:24 +00:00
|
|
|
|
void MotorBoard::pin_call(unsigned int pinNum)
|
|
|
|
|
{
|
2024-03-09 07:38:23 +00:00
|
|
|
|
if(!event_cb_)
|
|
|
|
|
{
|
|
|
|
|
unsigned int val = 0;
|
|
|
|
|
if (!read(MB_PORT_STATUS, val))
|
|
|
|
|
utils::to_log(LOG_LEVEL_FATAL, "read motorboard status failed.\n");
|
|
|
|
|
else
|
|
|
|
|
mb_events_.save(val, true);
|
|
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
|
static int index = 0;
|
2024-03-07 08:00:48 +00:00
|
|
|
|
// int os_m = os_mode(); //安路屏蔽计数 扫描过程中无法操作按键
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// if (m_os_mode != os_m)
|
|
|
|
|
// {
|
|
|
|
|
// m_os_mode = os_m;
|
|
|
|
|
// cv_os_mode.notify_all();
|
|
|
|
|
// if (m_glue.m_os_mode_call)
|
|
|
|
|
// m_glue.m_os_mode_call(m_os_mode);
|
|
|
|
|
// }
|
|
|
|
|
|
2024-03-07 08:00:48 +00:00
|
|
|
|
// if (m_os_mode) //安路屏蔽计数返回 以刷新计数状态
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// {
|
|
|
|
|
// LOG_TRACE("not scan mode");
|
|
|
|
|
// return;
|
|
|
|
|
// }
|
2023-12-20 07:23:24 +00:00
|
|
|
|
|
|
|
|
|
unsigned int val;
|
2024-01-09 06:26:46 +00:00
|
|
|
|
SMBSTATUS *s = (SMBSTATUS *)&val;
|
|
|
|
|
if (!read(MB_PORT_STATUS, val))
|
|
|
|
|
utils::to_log(LOG_LEVEL_FATAL, "read motorboard status failed.\n");
|
2024-03-07 08:00:48 +00:00
|
|
|
|
else
|
|
|
|
|
printf("\tmotorboard status = 0x%08X\n", val);
|
|
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
|
if(s->keep_last_paper) // (val & 0x800)
|
2024-01-05 09:36:50 +00:00
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
//printf("\n keep_last_paper ");
|
2023-12-20 07:23:24 +00:00
|
|
|
|
keep_last_paper=true;
|
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
|
if(s->sleep_set) // (val & 0x1000)
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
event_cb_(MOTOR_BORD_EVENT_SLEEP, s->sleep_conf);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
|
if(s->arrival_top_int) // (val & 0x80000)
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
event_cb_(MOTOR_BORD_EVENT_LIFTER_READY, 1);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
|
if(s->auto_feed)
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
event_cb_(MOTOR_BORD_EVENT_PAPER_READY, 1);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
|
if (val & 0x7c003FE)
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
SetKeyState(false);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
cv_error.notify_all();
|
2024-01-09 06:26:46 +00:00
|
|
|
|
event_cb_(MOTOR_BORD_EVENT_ERROR, val & 0x30efe); //0xefe index of 16:aquireimage error index of bit 17 :size check error
|
|
|
|
|
if(val & 0x30efe){
|
|
|
|
|
cv_paper_out.notify_all();
|
|
|
|
|
m_paperout_count++;
|
|
|
|
|
}
|
|
|
|
|
errormsg(val & 0x1c003fa);
|
|
|
|
|
if((val & 0x4) ||(val & 0x02000000))
|
|
|
|
|
{
|
|
|
|
|
if(val & 0x4){
|
2024-02-20 03:29:26 +00:00
|
|
|
|
PutMsg(STATUS_WORDS_ID(COVER_OPEN), devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
set_auto_paper(false,false);
|
|
|
|
|
autopaperkeystop?autopaperkeystop():void(0);
|
|
|
|
|
// if(m_statecontrol){
|
|
|
|
|
// m_statecontrol->setcoverstate(true);
|
|
|
|
|
// m_statecontrol->setmenuindex(0);
|
|
|
|
|
// }
|
|
|
|
|
}
|
|
|
|
|
else{
|
2024-02-20 03:29:26 +00:00
|
|
|
|
// PutMsg(STATUS_WORDS_ID(READY), devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// m_statecontrol?m_statecontrol->setcoverstate(false):void();
|
2024-02-21 02:44:40 +00:00
|
|
|
|
// printf("pin_call(%x)\n", val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
// if(smb_status->double_clean_f)
|
2024-02-20 03:29:26 +00:00
|
|
|
|
// PutMsg(STATUS_WORDS_ID(READY), devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
2024-02-21 02:44:40 +00:00
|
|
|
|
// printf("pin_call(%x)\n", val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
if (!s->scan_pulse)
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
|
|
|
|
cv_paper_in.notify_all();
|
2024-01-09 06:26:46 +00:00
|
|
|
|
unsigned int papercount = 0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
read(MB_PORT_MODE,papercount);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
SMBMODE smbmode = *(SMBMODE*)&papercount;
|
2024-03-07 08:00:48 +00:00
|
|
|
|
printf("paper in arm count = %d, motorcount = %d\n",++countindex,smbmode.scan_num);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
startcapimage(true);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
|
if(s->paper_left)
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
|
|
|
|
cv_paper_out.notify_all();
|
2024-01-09 06:26:46 +00:00
|
|
|
|
m_paperout_count++;
|
|
|
|
|
//printf("paper out time = %s \n",GetCurrentTimeStamp(2).c_str());
|
|
|
|
|
startcapimage(true);
|
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "m_paperout_count %d\n", (unsigned int)m_paperout_count);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
|
if (val & 0x400)
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
|
|
|
|
cv_scan_done.notify_all();
|
2024-01-09 06:26:46 +00:00
|
|
|
|
event_cb_(MOTOR_BORD_EVENT_SCAN_DONE, 1);
|
|
|
|
|
cv_paper_out.notify_all();
|
|
|
|
|
clear_error();
|
|
|
|
|
SetKeyState(false);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::write(unsigned int addr, unsigned int val)
|
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return m_regsAccess.get()?m_regsAccess->write(addr, val):false;
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::read(unsigned int addr, unsigned int &val)
|
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return m_regsAccess.get()?m_regsAccess->read(addr, val):false;
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
|
bool MotorBoard::set_time_error(int value){
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_TIME, val))
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return false;
|
|
|
|
|
SMBCONFIGTIME *smb_config = (SMBCONFIGTIME *)&val;
|
|
|
|
|
smb_config->error_time_set = value;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_TIME, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
2023-12-20 07:23:24 +00:00
|
|
|
|
|
|
|
|
|
bool MotorBoard::set_screw_inpect(bool enable)
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG, val))
|
2023-12-20 07:23:24 +00:00
|
|
|
|
return false;
|
|
|
|
|
SMBCONFIG *smb_config = (SMBCONFIG *)&val;
|
|
|
|
|
smb_config->skew_enable = enable;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
bool MotorBoard::get_screw_inpect()
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
read(MB_PORT_CONFIG, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
SMBCONFIG *smb_mode = (SMBCONFIG *)&val;
|
|
|
|
|
return smb_mode->skew_enable;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::set_screw_level(int level)
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG, val))
|
2023-12-20 07:23:24 +00:00
|
|
|
|
return false;
|
|
|
|
|
SMBCONFIG *smb_config = (SMBCONFIG *)&val;
|
|
|
|
|
smb_config->skew_parameter = level;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::set_auto_paper(bool enable,bool enkey){
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG, val))
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return false;
|
|
|
|
|
// m_statecontrol?m_statecontrol->setautopaperflag(enable,enkey):void(0);
|
|
|
|
|
SMBCONFIG *smb_config = (SMBCONFIG *)&val;
|
|
|
|
|
smb_config->autofeed_mode = enable;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::set_long_paper(bool enable)
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_CONFIG, val))
|
2023-12-20 07:23:24 +00:00
|
|
|
|
return false;
|
|
|
|
|
SMBCONFIG *smb_config = (SMBCONFIG *)&val;
|
|
|
|
|
smb_config->paper = enable;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_CONFIG, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int MotorBoard::get_screw_level()
|
|
|
|
|
{
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
auto ret= read(MB_PORT_CONFIG, val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
if(!ret)
|
|
|
|
|
return -1;
|
|
|
|
|
SMBCONFIG *smb_mode = (SMBCONFIG *)&val;
|
|
|
|
|
return smb_mode->skew_parameter;
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
|
void MotorBoard::start_countmode()
|
|
|
|
|
{
|
|
|
|
|
unsigned int regval=0;
|
|
|
|
|
|
2024-01-11 07:23:05 +00:00
|
|
|
|
read(MB_PORT_FUNCTION,regval);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "func6 regval = 0x%08x\n", regval);
|
|
|
|
|
SMBFUNC func = *(SMBFUNC*)®val;
|
|
|
|
|
func.param.work_mode =1;
|
|
|
|
|
func.param.func_feed_mid = 1;
|
|
|
|
|
func.param.func_clear_count = 1;
|
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "func6 value = 0x%08x\n", func.value);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_FUNCTION,func.value);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
func.param.func_encount = 1;
|
|
|
|
|
func.param.key_sound = 1;
|
|
|
|
|
func.param.func_clear_count = 0;
|
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "func6 value = 0x%08x\n", func.value);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_FUNCTION,func.value);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
func.param.func_encount = 0;
|
|
|
|
|
func.param.key_sound = 0;
|
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "func6 value = 0x%08x\n",func.value);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_FUNCTION,func.value);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2024-02-20 03:29:26 +00:00
|
|
|
|
void MotorBoard::PutMsg(int words, int align_v, int align_h, int font, int clear_method)
|
2024-01-09 06:26:46 +00:00
|
|
|
|
{
|
2024-02-21 02:44:40 +00:00
|
|
|
|
// devui::send_status_message(words, align_h, align_v, font, clear_method);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void MotorBoard::errormsg(uint value)
|
|
|
|
|
{
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if(value & 0x4)
|
2024-02-20 03:29:26 +00:00
|
|
|
|
PutMsg(STATUS_WORDS_ID(COVER_OPEN), devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
else if (value & 0x2)
|
2024-02-20 03:29:26 +00:00
|
|
|
|
PutMsg(STATUS_WORDS_ID(NO_PAPER), devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
else if (value & 0x8)
|
2024-02-20 03:29:26 +00:00
|
|
|
|
PutMsg(STATUS_WORDS_ID(FEED_ERR), devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
// else if (value & 0x10)
|
2024-02-20 03:29:26 +00:00
|
|
|
|
// PutMsg((int)DisType::Dis_Err_JamIn,devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
else if (value & 0x20)
|
2024-02-20 03:29:26 +00:00
|
|
|
|
PutMsg(STATUS_WORDS_ID(DOUBLE_FEED), devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
else if (value & 0x40)
|
2024-02-20 03:29:26 +00:00
|
|
|
|
PutMsg(STATUS_WORDS_ID(STAPLE), devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
else if (value & 0x80)
|
2024-02-20 03:29:26 +00:00
|
|
|
|
PutMsg(STATUS_WORDS_ID(ASKEW), devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
else if (value & 0x00010000)
|
2024-02-20 03:29:26 +00:00
|
|
|
|
PutMsg(STATUS_WORDS_ID(CIS_TIMEOUT), devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
else if((value & 0x1000010) == 0x1000010)
|
2024-02-20 03:29:26 +00:00
|
|
|
|
PutMsg(STATUS_WORDS_ID(JAMMED), devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
else if((value & 0x800010) == 0x800010)
|
2024-02-20 03:29:26 +00:00
|
|
|
|
PutMsg(STATUS_WORDS_ID(JAMMED), devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
else if((value & 0x400010) == 0x400010)
|
2024-02-20 03:29:26 +00:00
|
|
|
|
PutMsg(STATUS_WORDS_ID(JAMMED), devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void MotorBoard::SetKeyState(bool value)
|
|
|
|
|
{
|
|
|
|
|
// if(m_statecontrol)
|
|
|
|
|
// m_statecontrol->setrunstate(value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void MotorBoard::set_keystopenable(bool value){
|
|
|
|
|
unsigned int regval=0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
read(MB_PORT_FUNCTION,regval);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "func6 regval = 0x%08x\n", regval);
|
|
|
|
|
SMBFUNC func = *(SMBFUNC*)®val;
|
|
|
|
|
func.param.key_stop_enable = value;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_FUNCTION, regval);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void MotorBoard::set_freq(int motor_choose,int speedmode,int colormode,int dpi)
|
|
|
|
|
{
|
|
|
|
|
// MotorConfig cf;
|
|
|
|
|
// auto params = cf.GetMotorSpeedParams(motor_choose == 1?0:1,MotorConfig::MTBDType::MT_DRV);
|
|
|
|
|
// MotorSpeedParam param;
|
|
|
|
|
// //printf("\n---node.dpi ==%d && node.colormode == %d && node.speed == %d----- ",dpi,colormode,speedmode);
|
|
|
|
|
// for(auto &node : params)
|
|
|
|
|
// {
|
|
|
|
|
// if(node.dpi == dpi && node.colormode == colormode && node.speed == speedmode)
|
|
|
|
|
// {
|
|
|
|
|
// param = node.mt_param;
|
|
|
|
|
// //printf("\n-------------------------------------------------");
|
|
|
|
|
// break;
|
|
|
|
|
// }
|
|
|
|
|
// }
|
|
|
|
|
// std::vector<std::uint32_t> table;
|
|
|
|
|
// if(motor_choose == 0)
|
|
|
|
|
// {
|
|
|
|
|
// int x = 0; // (dpi == 1?(Get_static_jsonconfig().getscannerinfo().chu_motor_speed_200):(dpi == 2?Get_static_jsonconfig().getscannerinfo().chu_motor_speed_300 : Get_static_jsonconfig().getscannerinfo().chu_motor_speed_600));
|
|
|
|
|
// unsigned int regval=0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
// read(MB_PORT_FUNCTION,regval);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// SMBFUNC func = *(SMBFUNC*)®val;
|
|
|
|
|
// func.param.motor_choose = motor_choose;
|
|
|
|
|
// func.param.wr_en = 1;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
// write(MB_PORT_FUNCTION,func.value);
|
|
|
|
|
// write(MB_PORT_CONFIG_EX,x);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// //func.param.wr_en = 0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
// //write(MB_PORT_FUNCTION,func.value);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// return ;
|
|
|
|
|
// }
|
|
|
|
|
// if(motor_choose == 1)
|
|
|
|
|
// table = frep_cfg(param.finalPeriod,param.Fmin,param.stepnum,param.a,param.offset,param.finalDelay,param.acceleration_time);
|
|
|
|
|
// if(motor_choose == 2)
|
|
|
|
|
// table = frep_cfg(param.finalPeriod,param.Fmin,param.stepnum,param.a,param.offset,param.finalDelay,param.acceleration_time);
|
|
|
|
|
// if(motor_choose == 3)
|
|
|
|
|
// table = frep_cfg(param.finalPeriod,param.Fmin,param.stepnum,param.a,param.offset,param.finalDelay,param.acceleration_time);
|
|
|
|
|
// unsigned int regval=0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
// read(MB_PORT_FUNCTION,regval);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// SMBFUNC func = *(SMBFUNC*)®val;
|
|
|
|
|
// int start_addr_cuo = 0;
|
|
|
|
|
// #ifdef G200
|
|
|
|
|
// if(motor_choose ==1 && speedmode > 1 && dpi <3)
|
|
|
|
|
// start_addr_cuo = 63;
|
|
|
|
|
// if(motor_choose ==1 && dpi ==3)
|
|
|
|
|
// start_addr_cuo = 127;
|
|
|
|
|
// #endif
|
|
|
|
|
// printf("\nstart_addr_cuo =%d ",start_addr_cuo);
|
|
|
|
|
// for(int i =0;i<256;i++)
|
|
|
|
|
// {
|
|
|
|
|
// func.param.motor_choose = motor_choose;
|
|
|
|
|
// func.param.wr_en = 1;
|
|
|
|
|
// func.param.motor_addr =i;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
// write(MB_PORT_FUNCTION,func.value);
|
|
|
|
|
// write(MB_PORT_CONFIG_EX,i<start_addr_cuo?0:table[i-start_addr_cuo]);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// //printf("\nfreq= %x addr =%d ",table[i-start_addr_cuo],i);
|
|
|
|
|
// }
|
|
|
|
|
// func.param.wr_en = 0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
// write(MB_PORT_FUNCTION,func.value);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void MotorBoard::init_statecontrol()
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
m_regsAccess.reset(new UartRegsAccess(devPort, bauds, 0x07, 0x87));
|
|
|
|
|
m_intPinMonitor.reset(new PinMonitor(intport, std::bind(&MotorBoard::pin_call, this, std::placeholders::_1)));
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
|
|
|
|
m_os_mode = os_mode();
|
|
|
|
|
// m_statecontrol.reset(new StateControl(m_regsAccess,m_wake));
|
|
|
|
|
// m_statecontrol->setautopaperstopcallback([&]{
|
|
|
|
|
// autopaperkeystop?autopaperkeystop():void(0);
|
|
|
|
|
// if(m_config.g200params.is_autopaper)
|
|
|
|
|
// set_auto_paper(false,false);
|
|
|
|
|
// });
|
|
|
|
|
init_sensor_duty();
|
2024-02-20 03:29:26 +00:00
|
|
|
|
// PutMsg(STATUS_WORDS_ID(READY), devui::ALIGN_COMPONENT_MID, devui::ALIGN_COMPONENT_MID);
|
|
|
|
|
printf("init_statecontrol()\n");
|
2023-12-20 07:23:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void MotorBoard::release_statecontrol()
|
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
|
|
|
|
|
if(autopaperkeystop.operator bool())
|
|
|
|
|
autopaperkeystop();
|
|
|
|
|
set_auto_paper(false,false);
|
|
|
|
|
// m_statecontrol.reset();
|
2023-12-20 07:23:24 +00:00
|
|
|
|
m_regsAccess.reset();
|
|
|
|
|
m_intPinMonitor.reset();
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
|
void MotorBoard::setautopaperkeystopcallback(std::function<void()> func){
|
|
|
|
|
if(func)
|
|
|
|
|
autopaperkeystop = func;
|
|
|
|
|
// m_statecontrol?m_statecontrol->setautopaperstopcallback([&]{
|
|
|
|
|
// autopaperkeystop?autopaperkeystop():void(0);
|
|
|
|
|
// set_auto_paper(false,false);
|
|
|
|
|
// }):void(0);
|
|
|
|
|
}
|
|
|
|
|
void MotorBoard::startcapimage(bool value)
|
2023-12-20 07:23:24 +00:00
|
|
|
|
{
|
2024-01-09 06:26:46 +00:00
|
|
|
|
// if(m_config.g200params.is_fixedpaper)
|
|
|
|
|
// return;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
FILE *fp = fopen("/sys/class/tty/ttyUSB0/device/huagao_scanner", "w");
|
|
|
|
|
if (fp == NULL)
|
|
|
|
|
perror("startcapimage open filed");
|
|
|
|
|
else{
|
|
|
|
|
fprintf(fp, "%d", value ? 1 : 0);
|
|
|
|
|
fclose(fp);
|
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::set_sensor_pwm_duty(int sensorid,int duty)
|
|
|
|
|
{
|
2024-03-07 08:00:48 +00:00
|
|
|
|
//1:扫描;2:开盖;3:歪斜—1;4:歪斜-2;5:出纸口;6:有无纸
|
2024-01-09 06:26:46 +00:00
|
|
|
|
printf("set_sensor_pwm_duty type = %d duty = %d \n",sensorid,duty);
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_TIME, val))
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return false;
|
|
|
|
|
if(sensorid< 1 || sensorid >6)
|
|
|
|
|
return false;
|
|
|
|
|
if(duty< 2 || duty > 90)
|
|
|
|
|
return false;
|
|
|
|
|
SMBCONFIGTIME *smb_config_time = (SMBCONFIGTIME *)&val;
|
|
|
|
|
smb_config_time->sen_duty_set_sel = sensorid;
|
|
|
|
|
smb_config_time->duty_set = duty*8+50;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_TIME, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
smb_config_time->sen_duty_set_sel = 0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_TIME, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::enable_sensor_pwm(int sensorid,bool en)
|
|
|
|
|
{
|
|
|
|
|
std::uint32_t val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_TIME, val))
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return false;
|
|
|
|
|
if(sensorid< 1 || sensorid >6)
|
|
|
|
|
return false;
|
|
|
|
|
std::bitset<32> bit(val);
|
|
|
|
|
bit.set(sensorid+6,en);
|
|
|
|
|
val = bit.to_ulong();
|
|
|
|
|
printf("enable_sensor_pwm = %d \n",val);
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_TIME, val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool MotorBoard::set_ultrasonic_param(int type,int value){
|
|
|
|
|
//1:双张检测周期;2:有无纸检测周期;3:双张阈值;4:单张阈值;
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_ULTROSONIC, val))
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return false;
|
|
|
|
|
if(type< 1 || type >4)
|
|
|
|
|
return false;
|
|
|
|
|
printf("set_ultrasonic_param type = %d value = %d \n",type,value);
|
|
|
|
|
SMB_Ultrasonic_Config *tmp = (SMB_Ultrasonic_Config *)&val;
|
|
|
|
|
switch (type)
|
|
|
|
|
{
|
|
|
|
|
case 1:
|
|
|
|
|
tmp->param.double_check_cyc = value;
|
|
|
|
|
break;
|
|
|
|
|
case 2:
|
|
|
|
|
tmp->param.paper_check_cyc = value;
|
|
|
|
|
break;
|
|
|
|
|
case 3:
|
|
|
|
|
tmp->param.double_max = value;
|
|
|
|
|
break;
|
|
|
|
|
case 4:
|
|
|
|
|
tmp->param.single_max = value;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
printf("val = %d \n",val);
|
|
|
|
|
tmp->param.send_cyc_en = 1;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_ULTROSONIC,val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
tmp->param.send_cyc_en = 0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
return write(MB_PORT_ULTROSONIC,val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void MotorBoard::init_sensor_duty()
|
|
|
|
|
{
|
|
|
|
|
// auto p = Get_Static_SC().get_mem_param();
|
|
|
|
|
// std::vector<uint32_t> params(sizeof(SensorConfig::SensorConfig_Param)/sizeof(uint32_t));
|
|
|
|
|
// memcpy(¶ms[0],&p,sizeof(SensorConfig::SensorConfig_Param));
|
|
|
|
|
// for(int i = 0;i<params.size();i++){
|
|
|
|
|
// if(((i >= 0) || (i < 6)) && (params[i] < 100))
|
|
|
|
|
// {
|
|
|
|
|
// set_sensor_pwm_duty(i+1,params[i]);
|
|
|
|
|
// }
|
|
|
|
|
// if((i >= 6) || (i < 10))
|
|
|
|
|
// {
|
|
|
|
|
// set_ultrasonic_param(i-5,params[i]);
|
|
|
|
|
// }
|
|
|
|
|
// }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::uint32_t MotorBoard::get_ultrasonic_version(){
|
|
|
|
|
unsigned int val;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
if (!read(MB_PORT_ULTROSONIC, val))
|
2024-01-09 06:26:46 +00:00
|
|
|
|
return 0;
|
|
|
|
|
SMB_Ultrasonic_Config *tmp = (SMB_Ultrasonic_Config *)&val;
|
|
|
|
|
tmp->param.rd_ver_en = 1;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_ULTROSONIC,val);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
tmp->param.rd_ver_en = 0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
write(MB_PORT_ULTROSONIC,val);
|
2023-12-20 07:23:24 +00:00
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
2024-01-09 06:26:46 +00:00
|
|
|
|
read(0x08,val);
|
|
|
|
|
return val;
|
2023-12-29 02:53:04 +00:00
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
|
|
|
|
|
|
std::string MotorBoard::getmbversion(){
|
|
|
|
|
uint32_t value = 0;
|
2024-01-11 07:23:05 +00:00
|
|
|
|
read(MB_PORT_VERSION, value);
|
2024-01-09 06:26:46 +00:00
|
|
|
|
m_version = value;
|
|
|
|
|
printf("mb version: = %s \n", std::to_string(value).c_str());
|
|
|
|
|
return std::to_string(value);
|
2024-03-07 08:00:48 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
//
|
|
|
|
|
bool MotorBoard::wait_event(int event, int *evdata, int to_ms, int* fatal_ev, int* fatal_msg)
|
|
|
|
|
{
|
|
|
|
|
bool waited = false;
|
|
|
|
|
int evd = 0, fe = 0, msg = 0;
|
|
|
|
|
chronograph watch;
|
|
|
|
|
|
|
|
|
|
if(!evdata)
|
|
|
|
|
evdata = &evd;
|
|
|
|
|
if(!fatal_ev)
|
|
|
|
|
fatal_ev = &fe;
|
|
|
|
|
if(!fatal_msg)
|
|
|
|
|
fatal_msg = &msg;
|
|
|
|
|
|
|
|
|
|
*fatal_ev = 0;
|
|
|
|
|
while(watch.elapse_ms() < to_ms)
|
|
|
|
|
{
|
2024-03-09 07:38:23 +00:00
|
|
|
|
int val = 0;
|
|
|
|
|
SMBSTATUS *s = (SMBSTATUS *)&val;
|
2024-03-07 08:00:48 +00:00
|
|
|
|
|
2024-03-09 07:38:23 +00:00
|
|
|
|
// if (!read(MB_PORT_STATUS, val))
|
|
|
|
|
if(!mb_events_.take(val))
|
2024-03-07 08:00:48 +00:00
|
|
|
|
{
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
else if(val <= 1)
|
|
|
|
|
{
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(s->arrival_top_int) // (val & 0x80000)
|
|
|
|
|
{
|
|
|
|
|
if(event == MOTOR_BORD_EVENT_LIFTER_READY)
|
|
|
|
|
{
|
|
|
|
|
*evdata = 1;
|
|
|
|
|
waited = true;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if(s->auto_feed)
|
|
|
|
|
{
|
|
|
|
|
if(event == MOTOR_BORD_EVENT_PAPER_READY)
|
|
|
|
|
{
|
|
|
|
|
*evdata = 1;
|
|
|
|
|
waited = true;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if(s->paper_left)
|
|
|
|
|
{
|
|
|
|
|
startcapimage(true);
|
|
|
|
|
if(event == MOTOR_BORD_EVENT_PAPER_PASSING)
|
|
|
|
|
{
|
|
|
|
|
*evdata = 0;
|
|
|
|
|
waited = true;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if(s->motor_status)
|
|
|
|
|
{
|
|
|
|
|
*evdata = 0;
|
|
|
|
|
if(event == MOTOR_BORD_EVENT_SCAN_DONE)
|
|
|
|
|
{
|
|
|
|
|
waited = true;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
*fatal_ev = MOTOR_BORD_EVENT_SCAN_DONE;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if(!s->scan_pulse)
|
|
|
|
|
startcapimage(true);
|
|
|
|
|
if (val & 0x7c003FE)
|
|
|
|
|
{
|
|
|
|
|
*fatal_ev = MOTOR_BORD_EVENT_ERROR;
|
|
|
|
|
if(s->m1_paper_sin)
|
|
|
|
|
{
|
|
|
|
|
*evdata = SCANNER_ERR_DEVICE_NO_PAPER;
|
|
|
|
|
*fatal_msg = ID_WORDS_STATUS_NO_PAPER;
|
|
|
|
|
}
|
|
|
|
|
else if(s->open_machine)
|
|
|
|
|
{
|
|
|
|
|
*evdata = SCANNER_ERR_DEVICE_COVER_OPENNED;
|
|
|
|
|
*fatal_msg = ID_WORDS_STATUS_COVER_OPEN;
|
|
|
|
|
}
|
|
|
|
|
else if(s->pick_failed)
|
|
|
|
|
{
|
|
|
|
|
*evdata = SCANNER_ERR_DEVICE_FEEDING_PAPER;
|
|
|
|
|
*fatal_msg = ID_WORDS_STATUS_FEED_ERR;
|
|
|
|
|
}
|
|
|
|
|
else if(s->stop_jam && (s->jam_1 || s->jam_2 || s->jam_3))
|
|
|
|
|
{
|
|
|
|
|
*evdata = SCANNER_ERR_DEVICE_PAPER_JAMMED;
|
|
|
|
|
*fatal_msg = ID_WORDS_STATUS_JAMMED;
|
|
|
|
|
}
|
|
|
|
|
else if(s->double_paper)
|
|
|
|
|
{
|
|
|
|
|
*evdata = SCANNER_ERR_DEVICE_DOUBLE_FEEDING;
|
|
|
|
|
*fatal_msg = ID_WORDS_STATUS_DOUBLE_FEED;
|
|
|
|
|
}
|
|
|
|
|
else if(s->staple)
|
|
|
|
|
{
|
|
|
|
|
*evdata = SCANNER_ERR_DEVICE_STAPLE_ON;
|
|
|
|
|
*fatal_msg = ID_WORDS_STATUS_STAPLE;
|
|
|
|
|
}
|
|
|
|
|
else if(s->papertilted)
|
|
|
|
|
{
|
|
|
|
|
*evdata = SCANNER_ERR_DEVICE_PAPER_SKEW;
|
|
|
|
|
*fatal_msg = ID_WORDS_STATUS_ASKEW;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2024-03-09 07:38:23 +00:00
|
|
|
|
printf("\twait event %d = %s: evdata = %d, fatal_ev = %d\n", event, waited ? "true" : "false"
|
|
|
|
|
, *evdata, *fatal_ev);
|
|
|
|
|
|
2024-03-07 08:00:48 +00:00
|
|
|
|
return waited;
|
2024-01-09 06:26:46 +00:00
|
|
|
|
}
|