mirror
/
sane-project-backends
kopia lustrzana https://gitlab.com/sane-project/backends
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

genesys: Don't generate excessive amount of steps for the motor tables

merge-requests/463/merge
Povilas Kanapickas 2020-05-18 03:53:07 +03:00
rodzic 8e76d4ede9
commit 9c4f84f91a
10 zmienionych plików z 158 dodań i 177 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

26
backend/genesys/gl124.cpp
Wyświetl plik

@ -579,10 +579,10 @@ static void gl124_init_motor_regs_scan(Genesys_Device* dev,
/* scan and backtracking slope table */
auto scan_table = create_slope_table(dev->model->asic_type, dev->motor, yres,
scan_exposure_time, 1, motor_profile);
gl124_send_slope_table(dev, SCAN_TABLE, scan_table.table, scan_table.steps_count);
gl124_send_slope_table(dev, BACKTRACK_TABLE, scan_table.table, scan_table.steps_count);
gl124_send_slope_table(dev, SCAN_TABLE, scan_table.table, scan_table.table.size());
gl124_send_slope_table(dev, BACKTRACK_TABLE, scan_table.table, scan_table.table.size());
reg->set16(REG_STEPNO, scan_table.steps_count);
reg->set16(REG_STEPNO, scan_table.table.size());
/* fast table */
fast_dpi=yres;
@ -595,23 +595,23 @@ static void gl124_init_motor_regs_scan(Genesys_Device* dev,
*/
auto fast_table = create_slope_table(dev->model->asic_type, dev->motor, fast_dpi,
scan_exposure_time, 1, motor_profile);
gl124_send_slope_table(dev, STOP_TABLE, fast_table.table, fast_table.steps_count);
gl124_send_slope_table(dev, FAST_TABLE, fast_table.table, fast_table.steps_count);
gl124_send_slope_table(dev, STOP_TABLE, fast_table.table, fast_table.table.size());
gl124_send_slope_table(dev, FAST_TABLE, fast_table.table, fast_table.table.size());
reg->set16(REG_FASTNO, fast_table.steps_count);
reg->set16(REG_FSHDEC, fast_table.steps_count);
reg->set16(REG_FMOVNO, fast_table.steps_count);
reg->set16(REG_FASTNO, fast_table.table.size());
reg->set16(REG_FSHDEC, fast_table.table.size());
reg->set16(REG_FMOVNO, fast_table.table.size());
/* substract acceleration distance from feedl */
feedl=feed_steps;
feedl <<= static_cast<unsigned>(motor_profile.step_type);
dist = scan_table.steps_count;
dist = scan_table.table.size();
if (has_flag(flags, ScanFlag::FEEDING)) {
dist *= 2;
}
if (use_fast_fed) {
dist += fast_table.steps_count * 2;
dist += fast_table.table.size() * 2;
}
/* get sure we don't use insane value */
@ -627,9 +627,9 @@ static void gl124_init_motor_regs_scan(Genesys_Device* dev,
sanei_genesys_calculate_zmod(use_fast_fed,
scan_exposure_time,
scan_table.table,
scan_table.steps_count,
scan_table.table.size(),
feedl,
scan_table.steps_count,
scan_table.table.size(),
&z1,
&z2);
@ -641,7 +641,7 @@ static void gl124_init_motor_regs_scan(Genesys_Device* dev,
reg->set8(REG_0xA0, (static_cast<unsigned>(motor_profile.step_type) << REG_0xA0S_STEPSEL) |
(static_cast<unsigned>(motor_profile.step_type) << REG_0xA0S_FSTPSEL));
reg->set16(REG_FMOVDEC, fast_table.steps_count);
reg->set16(REG_FMOVDEC, fast_table.table.size());
}
/** @brief setup optical related registers

36
backend/genesys/gl646.cpp
Wyświetl plik

@ -651,17 +651,17 @@ void CommandSetGl646::init_regs_for_scan_session(Genesys_Device* dev, const Gene
// the steps count must be different by at most 128, otherwise it's impossible to construct
// a proper backtracking curve. We're using slightly lower limit to allow at least a minimum
// distance between accelerations (forward_steps, backward_steps)
if (slope_table1.steps_count > slope_table2.steps_count + 100) {
slope_table2.steps_count += slope_table1.steps_count - 100;
if (slope_table1.table.size() > slope_table2.table.size() + 100) {
slope_table2.expand_table(slope_table1.table.size() - 100);
}
if (slope_table2.steps_count > slope_table1.steps_count + 100) {
slope_table1.steps_count += slope_table2.steps_count - 100;
if (slope_table2.table.size() > slope_table1.table.size() + 100) {
slope_table1.expand_table(slope_table2.table.size() - 100);
}
if (slope_table1.steps_count >= slope_table2.steps_count) {
backward_steps += (slope_table1.steps_count - slope_table2.steps_count) * 2;
if (slope_table1.table.size() >= slope_table2.table.size()) {
backward_steps += (slope_table1.table.size() - slope_table2.table.size()) * 2;
} else {
forward_steps += (slope_table2.steps_count - slope_table1.steps_count) * 2;
forward_steps += (slope_table2.table.size() - slope_table1.table.size()) * 2;
}
if (forward_steps > 255) {
@ -677,8 +677,8 @@ void CommandSetGl646::init_regs_for_scan_session(Genesys_Device* dev, const Gene
forward_steps -= backward_steps - 255;
}
regs->find_reg(0x21).value = slope_table1.steps_count;
regs->find_reg(0x24).value = slope_table2.steps_count;
regs->find_reg(0x21).value = slope_table1.table.size();
regs->find_reg(0x24).value = slope_table2.table.size();
regs->find_reg(0x22).value = forward_steps;
regs->find_reg(0x23).value = backward_steps;
@ -801,12 +801,12 @@ void CommandSetGl646::init_regs_for_scan_session(Genesys_Device* dev, const Gene
if (motor->fastfed)
{
feedl = feedl - 2 * slope_table2.steps_count -
(slope_table1.steps_count >> step_shift);
feedl = feedl - 2 * slope_table2.table.size() -
(slope_table1.table.size() >> step_shift);
}
else
{
feedl = feedl - (slope_table1.steps_count >> step_shift);
feedl = feedl - (slope_table1.table.size() >> step_shift);
}
break;
}
@ -823,7 +823,7 @@ void CommandSetGl646::init_regs_for_scan_session(Genesys_Device* dev, const Gene
sanei_genesys_calculate_zmod(regs->find_reg(0x02).value & REG_0x02_FASTFED,
sensor.exposure_lperiod,
slope_table1.table,
slope_table1.steps_count,
slope_table1.table.size(),
move, motor->fwdbwd, &z1, &z2);
/* no z1/z2 for sheetfed scanners */
@ -833,7 +833,7 @@ void CommandSetGl646::init_regs_for_scan_session(Genesys_Device* dev, const Gene
}
regs->set16(REG_Z1MOD, z1);
regs->set16(REG_Z2MOD, z2);
regs->find_reg(0x6b).value = slope_table2.steps_count;
regs->find_reg(0x6b).value = slope_table2.table.size();
regs->find_reg(0x6c).value =
(regs->find_reg(0x6c).value & REG_0x6C_TGTIME) | ((z1 >> 13) & 0x38) | ((z2 >> 16)
& 0x07);
@ -873,8 +873,8 @@ void CommandSetGl646::init_regs_for_scan_session(Genesys_Device* dev, const Gene
}
}
gl646_send_slope_table(dev, 0, slope_table1.table, slope_table1.steps_count);
gl646_send_slope_table(dev, 1, slope_table2.table, slope_table2.steps_count);
gl646_send_slope_table(dev, 0, slope_table1.table, slope_table1.table.size());
gl646_send_slope_table(dev, 1, slope_table2.table, slope_table2.table.size());
}
/**
@ -1445,7 +1445,7 @@ void CommandSetGl646::load_document(Genesys_Device* dev) const
// send regs
// start motor
// wait e1 status to become e0
gl646_send_slope_table(dev, 1, slope_table.table, slope_table.steps_count);
gl646_send_slope_table(dev, 1, slope_table.table, slope_table.table.size());
dev->interface->write_registers(regs);
@ -1601,7 +1601,7 @@ void CommandSetGl646::eject_document(Genesys_Device* dev) const
// send regs
// start motor
// wait c1 status to become c8 : HOMESNR and ~MOTFLAG
gl646_send_slope_table(dev, 1, slope_table.table, slope_table.steps_count);
gl646_send_slope_table(dev, 1, slope_table.table, slope_table.table.size());
dev->interface->write_registers(regs);

68
backend/genesys/gl841.cpp
Wyświetl plik

@ -605,7 +605,7 @@ static void gl841_init_motor_regs_feed(Genesys_Device* dev, const Genesys_Sensor
StepType::FULL, fast_exposure,
dev->motor.base_ydpi / 4);
feedl = feed_steps - fast_table.steps_count * 2;
feedl = feed_steps - fast_table.table.size() * 2;
use_fast_fed = 1;
reg->set8(0x3d, (feedl >> 16) & 0xf);
@ -641,15 +641,15 @@ static void gl841_init_motor_regs_feed(Genesys_Device* dev, const Genesys_Sensor
reg->find_reg(0x02).value &= ~REG_0x02_MTRREV;
}
gl841_send_slope_table(dev, sensor, 3, fast_table.table, fast_table.steps_count);
gl841_send_slope_table(dev, sensor, 3, fast_table.table, fast_table.table.size());
reg->set8(0x67, 0x3f);
reg->set8(0x68, 0x3f);
reg->set8(REG_STEPNO, 0);
reg->set8(REG_FASTNO, 0);
reg->set8(0x69, 0);
reg->set8(0x6a, (fast_table.steps_count >> 1) + (fast_table.steps_count & 1));
reg->set8(0x5f, (fast_table.steps_count >> 1) + (fast_table.steps_count & 1));
reg->set8(0x6a, (fast_table.table.size() >> 1) + (fast_table.table.size() & 1));
reg->set8(0x5f, (fast_table.table.size() >> 1) + (fast_table.table.size() & 1));
}
static void gl841_init_motor_regs_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
@ -708,9 +708,9 @@ static void gl841_init_motor_regs_scan(Genesys_Device* dev, const Genesys_Sensor
auto back_table = sanei_genesys_create_slope_table3(dev->model->asic_type, dev->motor,
motor_profile.step_type, 0, scan_yres);
if (feed_steps < (slow_table.steps_count >> static_cast<unsigned>(motor_profile.step_type))) {
if (feed_steps < (slow_table.table.size() >> static_cast<unsigned>(motor_profile.step_type))) {
/*TODO: what should we do here?? go back to exposure calculation?*/
feed_steps = slow_table.steps_count >> static_cast<unsigned>(motor_profile.step_type);
feed_steps = slow_table.table.size() >> static_cast<unsigned>(motor_profile.step_type);
}
auto fast_table = sanei_genesys_create_slope_table3(dev->model->asic_type, dev->motor,
@ -718,12 +718,12 @@ static void gl841_init_motor_regs_scan(Genesys_Device* dev, const Genesys_Sensor
dev->motor.base_ydpi / 4);
unsigned max_fast_slope_steps_count = 1;
if (feed_steps > (slow_table.steps_count >> static_cast<unsigned>(motor_profile.step_type)) + 2) {
if (feed_steps > (slow_table.table.size() >> static_cast<unsigned>(motor_profile.step_type)) + 2) {
max_fast_slope_steps_count = (feed_steps -
(slow_table.steps_count >> static_cast<unsigned>(motor_profile.step_type))) / 2;
(slow_table.table.size() >> static_cast<unsigned>(motor_profile.step_type))) / 2;
}
if (fast_table.steps_count > max_fast_slope_steps_count) {
if (fast_table.table.size() > max_fast_slope_steps_count) {
fast_table.slice_steps(max_fast_slope_steps_count);
}
@ -735,8 +735,8 @@ static void gl841_init_motor_regs_scan(Genesys_Device* dev, const Genesys_Sensor
2-feed mode */
use_fast_fed = 0;
}
else if (feed_steps < fast_table.steps_count * 2 +
(slow_table.steps_count >> static_cast<unsigned>(motor_profile.step_type)))
else if (feed_steps < fast_table.table.size() * 2 +
(slow_table.table.size() >> static_cast<unsigned>(motor_profile.step_type)))
{
use_fast_fed = 0;
DBG(DBG_info, "%s: feed too short, slow move forced.\n", __func__);
@ -751,24 +751,24 @@ static void gl841_init_motor_regs_scan(Genesys_Device* dev, const Genesys_Sensor
/*we use full steps as base unit here*/
fast_time =
fast_exposure / 4 *
(feed_steps - fast_table.steps_count*2 -
(slow_table.steps_count >> static_cast<unsigned>(motor_profile.step_type)))
(feed_steps - fast_table.table.size()*2 -
(slow_table.table.size() >> static_cast<unsigned>(motor_profile.step_type)))
+ fast_table.pixeltime_sum*2 + slow_table.pixeltime_sum;
slow_time =
(scan_exposure_time * scan_yres) / dev->motor.base_ydpi *
(feed_steps - (slow_table.steps_count >> static_cast<unsigned>(motor_profile.step_type)))
(feed_steps - (slow_table.table.size() >> static_cast<unsigned>(motor_profile.step_type)))
+ slow_table.pixeltime_sum;
use_fast_fed = fast_time < slow_time;
}
if (use_fast_fed) {
feedl = feed_steps - fast_table.steps_count * 2 -
(slow_table.steps_count >> static_cast<unsigned>(motor_profile.step_type));
} else if ((feed_steps << static_cast<unsigned>(motor_profile.step_type)) < slow_table.steps_count) {
feedl = feed_steps - fast_table.table.size() * 2 -
(slow_table.table.size() >> static_cast<unsigned>(motor_profile.step_type));
} else if ((feed_steps << static_cast<unsigned>(motor_profile.step_type)) < slow_table.table.size()) {
feedl = 0;
} else {
feedl = (feed_steps << static_cast<unsigned>(motor_profile.step_type)) - slow_table.steps_count;
feedl = (feed_steps << static_cast<unsigned>(motor_profile.step_type)) - slow_table.table.size();
}
DBG(DBG_info, "%s: Decided to use %s mode\n", __func__, use_fast_fed?"fast feed":"slow feed");
@ -803,16 +803,16 @@ static void gl841_init_motor_regs_scan(Genesys_Device* dev, const Genesys_Sensor
reg->find_reg(0x02).value &= ~0x40;
}
gl841_send_slope_table(dev, sensor, 0, slow_table.table, slow_table.steps_count);
gl841_send_slope_table(dev, sensor, 1, back_table.table, back_table.steps_count);
gl841_send_slope_table(dev, sensor, 2, slow_table.table, slow_table.steps_count);
gl841_send_slope_table(dev, sensor, 0, slow_table.table, slow_table.table.size());
gl841_send_slope_table(dev, sensor, 1, back_table.table, back_table.table.size());
gl841_send_slope_table(dev, sensor, 2, slow_table.table, slow_table.table.size());
if (use_fast_fed) {
gl841_send_slope_table(dev, sensor, 3, fast_table.table, fast_table.steps_count);
gl841_send_slope_table(dev, sensor, 3, fast_table.table, fast_table.table.size());
}
if (has_flag(flags, ScanFlag::AUTO_GO_HOME)) {
gl841_send_slope_table(dev, sensor, 4, fast_table.table, fast_table.steps_count);
gl841_send_slope_table(dev, sensor, 4, fast_table.table, fast_table.table.size());
}
/* now reg 0x21 and 0x24 are available, we can calculate reg 0x22 and 0x23,
@ -821,18 +821,18 @@ static void gl841_init_motor_regs_scan(Genesys_Device* dev, const Genesys_Sensor
2*STEPNO+FWDSTEP=2*FASTNO+BWDSTEP
*/
/* steps of table 0*/
if (min_restep < slow_table.steps_count * 2 + 2) {
min_restep = slow_table.steps_count * 2 + 2;
if (min_restep < slow_table.table.size() * 2 + 2) {
min_restep = slow_table.table.size() * 2 + 2;
}
/* steps of table 1*/
if (min_restep < back_table.steps_count * 2 + 2) {
min_restep = back_table.steps_count * 2 + 2;
if (min_restep < back_table.table.size() * 2 + 2) {
min_restep = back_table.table.size() * 2 + 2;
}
/* steps of table 0*/
reg->set8(REG_FWDSTEP, min_restep - slow_table.steps_count*2);
reg->set8(REG_FWDSTEP, min_restep - slow_table.table.size()*2);
/* steps of table 1*/
reg->set8(REG_BWDSTEP, min_restep - back_table.steps_count*2);
reg->set8(REG_BWDSTEP, min_restep - back_table.table.size()*2);
/*
for z1/z2:
@ -855,11 +855,11 @@ static void gl841_init_motor_regs_scan(Genesys_Device* dev, const Genesys_Sensor
reg->find_reg(REG_0x1E).value |= scan_dummy;
reg->set8(0x67, 0x3f | (static_cast<unsigned>(motor_profile.step_type) << 6));
reg->set8(0x68, 0x3f);
reg->set8(REG_STEPNO, (slow_table.steps_count >> 1) + (slow_table.steps_count & 1));
reg->set8(REG_FASTNO, (back_table.steps_count >> 1) + (back_table.steps_count & 1));
reg->set8(0x69, (slow_table.steps_count >> 1) + (slow_table.steps_count & 1));
reg->set8(0x6a, (fast_table.steps_count >> 1) + (fast_table.steps_count & 1));
reg->set8(0x5f, (fast_table.steps_count >> 1) + (fast_table.steps_count & 1));
reg->set8(REG_STEPNO, (slow_table.table.size() >> 1) + (slow_table.table.size() & 1));
reg->set8(REG_FASTNO, (back_table.table.size() >> 1) + (back_table.table.size() & 1));
reg->set8(0x69, (slow_table.table.size() >> 1) + (slow_table.table.size() & 1));
reg->set8(0x6a, (fast_table.table.size() >> 1) + (fast_table.table.size() & 1));
reg->set8(0x5f, (fast_table.table.size() >> 1) + (fast_table.table.size() & 1));
}
static void gl841_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,

28
backend/genesys/gl842.cpp
Wyświetl plik

@ -322,13 +322,13 @@ static void gl842_init_motor_regs_scan(Genesys_Device* dev,
auto scan_table = create_slope_table(dev->model->asic_type, dev->motor, scan_yres, exposure,
step_multiplier, motor_profile);
gl842_send_slope_table(dev, SCAN_TABLE, scan_table.table, scan_table.steps_count);
gl842_send_slope_table(dev, BACKTRACK_TABLE, scan_table.table, scan_table.steps_count);
gl842_send_slope_table(dev, STOP_TABLE, scan_table.table, scan_table.steps_count);
gl842_send_slope_table(dev, SCAN_TABLE, scan_table.table, scan_table.table.size());
gl842_send_slope_table(dev, BACKTRACK_TABLE, scan_table.table, scan_table.table.size());
gl842_send_slope_table(dev, STOP_TABLE, scan_table.table, scan_table.table.size());
reg->set8(REG_STEPNO, scan_table.steps_count / step_multiplier);
reg->set8(REG_FASTNO, scan_table.steps_count / step_multiplier);
reg->set8(REG_FSHDEC, scan_table.steps_count / step_multiplier);
reg->set8(REG_STEPNO, scan_table.table.size() / step_multiplier);
reg->set8(REG_FASTNO, scan_table.table.size() / step_multiplier);
reg->set8(REG_FSHDEC, scan_table.table.size() / step_multiplier);
// fast table
const auto* fast_profile = get_motor_profile_ptr(dev->motor.fast_profiles, 0, session);
@ -339,10 +339,10 @@ static void gl842_init_motor_regs_scan(Genesys_Device* dev,
auto fast_table = create_slope_table_fastest(dev->model->asic_type, step_multiplier,
*fast_profile);
gl842_send_slope_table(dev, FAST_TABLE, fast_table.table, fast_table.steps_count);
gl842_send_slope_table(dev, HOME_TABLE, fast_table.table, fast_table.steps_count);
gl842_send_slope_table(dev, FAST_TABLE, fast_table.table, fast_table.table.size());
gl842_send_slope_table(dev, HOME_TABLE, fast_table.table, fast_table.table.size());
reg->set8(REG_FMOVNO, fast_table.steps_count / step_multiplier);
reg->set8(REG_FMOVNO, fast_table.table.size() / step_multiplier);
if (motor_profile.motor_vref != -1 && fast_profile->motor_vref != 1) {
std::uint8_t vref = 0;
@ -357,10 +357,10 @@ static void gl842_init_motor_regs_scan(Genesys_Device* dev,
unsigned feedl = feed_steps;
feedl <<= static_cast<unsigned>(motor_profile.step_type);
unsigned dist = scan_table.steps_count / step_multiplier;
unsigned dist = scan_table.table.size() / step_multiplier;
if (use_fast_fed) {
dist += (fast_table.steps_count / step_multiplier) * 2;
dist += (fast_table.table.size() / step_multiplier) * 2;
}
// make sure when don't insane value : XXX STEF XXX in this case we should
@ -378,9 +378,9 @@ static void gl842_init_motor_regs_scan(Genesys_Device* dev,
sanei_genesys_calculate_zmod(use_fast_fed,
exposure,
scan_table.table,
scan_table.steps_count / step_multiplier,
scan_table.table.size() / step_multiplier,
feedl,
scan_table.steps_count / step_multiplier,
scan_table.table.size() / step_multiplier,
&z1,
&z2);
if (scan_yres > 600) {
@ -399,7 +399,7 @@ static void gl842_init_motor_regs_scan(Genesys_Device* dev,
REG_0x68_FSTPSEL);
// steps for STOP table
reg->set8(REG_FMOVDEC, fast_table.steps_count / step_multiplier);
reg->set8(REG_FMOVDEC, fast_table.table.size() / step_multiplier);
}
static void gl842_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,

28
backend/genesys/gl843.cpp
Wyświetl plik

@ -772,13 +772,13 @@ static void gl843_init_motor_regs_scan(Genesys_Device* dev,
auto scan_table = create_slope_table(dev->model->asic_type, dev->motor, scan_yres, exposure,
step_multiplier, motor_profile);
gl843_send_slope_table(dev, SCAN_TABLE, scan_table.table, scan_table.steps_count);
gl843_send_slope_table(dev, BACKTRACK_TABLE, scan_table.table, scan_table.steps_count);
gl843_send_slope_table(dev, STOP_TABLE, scan_table.table, scan_table.steps_count);
gl843_send_slope_table(dev, SCAN_TABLE, scan_table.table, scan_table.table.size());
gl843_send_slope_table(dev, BACKTRACK_TABLE, scan_table.table, scan_table.table.size());
gl843_send_slope_table(dev, STOP_TABLE, scan_table.table, scan_table.table.size());
reg->set8(REG_STEPNO, scan_table.steps_count / step_multiplier);
reg->set8(REG_FASTNO, scan_table.steps_count / step_multiplier);
reg->set8(REG_FSHDEC, scan_table.steps_count / step_multiplier);
reg->set8(REG_STEPNO, scan_table.table.size() / step_multiplier);
reg->set8(REG_FASTNO, scan_table.table.size() / step_multiplier);
reg->set8(REG_FSHDEC, scan_table.table.size() / step_multiplier);
// fast table
const auto* fast_profile = get_motor_profile_ptr(dev->motor.fast_profiles, 0, session);
@ -789,10 +789,10 @@ static void gl843_init_motor_regs_scan(Genesys_Device* dev,
auto fast_table = create_slope_table_fastest(dev->model->asic_type, step_multiplier,
*fast_profile);
gl843_send_slope_table(dev, FAST_TABLE, fast_table.table, fast_table.steps_count);
gl843_send_slope_table(dev, HOME_TABLE, fast_table.table, fast_table.steps_count);
gl843_send_slope_table(dev, FAST_TABLE, fast_table.table, fast_table.table.size());
gl843_send_slope_table(dev, HOME_TABLE, fast_table.table, fast_table.table.size());
reg->set8(REG_FMOVNO, fast_table.steps_count / step_multiplier);
reg->set8(REG_FMOVNO, fast_table.table.size() / step_multiplier);
if (motor_profile.motor_vref != -1 && fast_profile->motor_vref != 1) {
std::uint8_t vref = 0;
@ -807,10 +807,10 @@ static void gl843_init_motor_regs_scan(Genesys_Device* dev,
feedl=feed_steps;
feedl <<= static_cast<unsigned>(motor_profile.step_type);
dist = scan_table.steps_count / step_multiplier;
dist = scan_table.table.size() / step_multiplier;
if (use_fast_fed) {
dist += (fast_table.steps_count / step_multiplier) * 2;
dist += (fast_table.table.size() / step_multiplier) * 2;
}
/* get sure when don't insane value : XXX STEF XXX in this case we should
@ -828,9 +828,9 @@ static void gl843_init_motor_regs_scan(Genesys_Device* dev,
sanei_genesys_calculate_zmod(use_fast_fed,
exposure,
scan_table.table,
scan_table.steps_count / step_multiplier,
scan_table.table.size() / step_multiplier,
feedl,
scan_table.steps_count / step_multiplier,
scan_table.table.size() / step_multiplier,
&z1,
&z2);
if(scan_yres>600)
@ -848,7 +848,7 @@ static void gl843_init_motor_regs_scan(Genesys_Device* dev,
reg->set8_mask(REG_0x68, static_cast<unsigned>(fast_profile->step_type) << REG_0x68S_FSTPSEL, 0xc0);
// steps for STOP table
reg->set8(REG_FMOVDEC, fast_table.steps_count / step_multiplier);
reg->set8(REG_FMOVDEC, fast_table.table.size() / step_multiplier);
if (dev->model->model_id == ModelId::PANASONIC_KV_SS080 ||
dev->model->model_id == ModelId::HP_SCANJET_4850C ||

28
backend/genesys/gl846.cpp
Wyświetl plik

@ -447,13 +447,13 @@ static void gl846_init_motor_regs_scan(Genesys_Device* dev,
auto scan_table = create_slope_table(dev->model->asic_type, dev->motor, scan_yres,
scan_exposure_time, step_multiplier, motor_profile);
gl846_send_slope_table(dev, SCAN_TABLE, scan_table.table, scan_table.steps_count);
gl846_send_slope_table(dev, BACKTRACK_TABLE, scan_table.table, scan_table.steps_count);
gl846_send_slope_table(dev, STOP_TABLE, scan_table.table, scan_table.steps_count);
gl846_send_slope_table(dev, SCAN_TABLE, scan_table.table, scan_table.table.size());
gl846_send_slope_table(dev, BACKTRACK_TABLE, scan_table.table, scan_table.table.size());
gl846_send_slope_table(dev, STOP_TABLE, scan_table.table, scan_table.table.size());
reg->set8(REG_STEPNO, scan_table.steps_count / step_multiplier);
reg->set8(REG_FASTNO, scan_table.steps_count / step_multiplier);
reg->set8(REG_FSHDEC, scan_table.steps_count / step_multiplier);
reg->set8(REG_STEPNO, scan_table.table.size() / step_multiplier);
reg->set8(REG_FASTNO, scan_table.table.size() / step_multiplier);
reg->set8(REG_FSHDEC, scan_table.table.size() / step_multiplier);
// fast table
const auto* fast_profile = get_motor_profile_ptr(dev->motor.fast_profiles, 0, session);
@ -464,11 +464,11 @@ static void gl846_init_motor_regs_scan(Genesys_Device* dev,
auto fast_table = create_slope_table_fastest(dev->model->asic_type, step_multiplier,
*fast_profile);
gl846_send_slope_table(dev, FAST_TABLE, fast_table.table, fast_table.steps_count);
gl846_send_slope_table(dev, HOME_TABLE, fast_table.table, fast_table.steps_count);
gl846_send_slope_table(dev, FAST_TABLE, fast_table.table, fast_table.table.size());
gl846_send_slope_table(dev, HOME_TABLE, fast_table.table, fast_table.table.size());
reg->set8(REG_FMOVNO, fast_table.steps_count / step_multiplier);
reg->set8(REG_FMOVDEC, fast_table.steps_count / step_multiplier);
reg->set8(REG_FMOVNO, fast_table.table.size() / step_multiplier);
reg->set8(REG_FMOVDEC, fast_table.table.size() / step_multiplier);
if (motor_profile.motor_vref != -1 && fast_profile->motor_vref != 1) {
std::uint8_t vref = 0;
@ -483,13 +483,13 @@ static void gl846_init_motor_regs_scan(Genesys_Device* dev,
unsigned dist = 0;
if (use_fast_fed) {
feedl <<= static_cast<unsigned>(fast_profile->step_type);
dist = (scan_table.steps_count + 2 * fast_table.steps_count);
dist = (scan_table.table.size() + 2 * fast_table.table.size());
// TODO read and decode REG_0xAB
dist += (reg->get8(0x5e) & 31);
dist += reg->get8(REG_FEDCNT);
} else {
feedl <<= static_cast<unsigned>(motor_profile.step_type);
dist = scan_table.steps_count;
dist = scan_table.table.size();
if (has_flag(flags, ScanFlag::FEEDING)) {
dist *= 2;
}
@ -539,7 +539,7 @@ static void gl846_init_motor_regs_scan(Genesys_Device* dev,
dev->interface->write_register(REG_0x6C, val);
*/
unsigned min_restep = (scan_table.steps_count / step_multiplier) / 2 - 1;
unsigned min_restep = (scan_table.table.size() / step_multiplier) / 2 - 1;
if (min_restep < 1) {
min_restep = 1;
}
@ -551,7 +551,7 @@ static void gl846_init_motor_regs_scan(Genesys_Device* dev,
sanei_genesys_calculate_zmod(use_fast_fed,
scan_exposure_time * ccdlmt * tgtime,
scan_table.table,
scan_table.steps_count,
scan_table.table.size(),
feedl,
min_restep * step_multiplier,
&z1,

28
backend/genesys/gl847.cpp
Wyświetl plik

@ -339,8 +339,8 @@ static void gl847_init_motor_regs_scan(Genesys_Device* dev,
// scan and backtracking slope table
auto scan_table = create_slope_table(dev->model->asic_type, dev->motor, scan_yres,
scan_exposure_time, step_multiplier, motor_profile);
gl847_send_slope_table(dev, SCAN_TABLE, scan_table.table, scan_table.steps_count);
gl847_send_slope_table(dev, BACKTRACK_TABLE, scan_table.table, scan_table.steps_count);
gl847_send_slope_table(dev, SCAN_TABLE, scan_table.table, scan_table.table.size());
gl847_send_slope_table(dev, BACKTRACK_TABLE, scan_table.table, scan_table.table.size());
// fast table
unsigned fast_dpi = sanei_genesys_get_lowest_ydpi(dev);
@ -357,9 +357,9 @@ static void gl847_init_motor_regs_scan(Genesys_Device* dev,
auto fast_table = create_slope_table(dev->model->asic_type, dev->motor, fast_dpi,
scan_exposure_time, step_multiplier, fast_motor_profile);
gl847_send_slope_table(dev, STOP_TABLE, fast_table.table, fast_table.steps_count);
gl847_send_slope_table(dev, FAST_TABLE, fast_table.table, fast_table.steps_count);
gl847_send_slope_table(dev, HOME_TABLE, fast_table.table, fast_table.steps_count);
gl847_send_slope_table(dev, STOP_TABLE, fast_table.table, fast_table.table.size());
gl847_send_slope_table(dev, FAST_TABLE, fast_table.table, fast_table.table.size());
gl847_send_slope_table(dev, HOME_TABLE, fast_table.table, fast_table.table.size());
// correct move distance by acceleration and deceleration amounts
unsigned feedl = feed_steps;
@ -367,13 +367,13 @@ static void gl847_init_motor_regs_scan(Genesys_Device* dev,
if (use_fast_fed)
{
feedl <<= static_cast<unsigned>(fast_step_type);
dist = (scan_table.steps_count + 2 * fast_table.steps_count);
dist = (scan_table.table.size() + 2 * fast_table.table.size());
// TODO read and decode REG_0xAB
dist += (reg->get8(0x5e) & 31);
dist += reg->get8(REG_FEDCNT);
} else {
feedl <<= static_cast<unsigned>(motor_profile.step_type);
dist = scan_table.steps_count;
dist = scan_table.table.size();
if (has_flag(flags, ScanFlag::FEEDING)) {
dist *= 2;
}
@ -410,7 +410,7 @@ static void gl847_init_motor_regs_scan(Genesys_Device* dev,
val = effective | REG_0x6C_GPIO10;
dev->interface->write_register(REG_0x6C, val);
unsigned min_restep = scan_table.steps_count / (2 * step_multiplier) - 1;
unsigned min_restep = scan_table.table.size() / (2 * step_multiplier) - 1;
if (min_restep < 1) {
min_restep = 1;
}
@ -422,7 +422,7 @@ static void gl847_init_motor_regs_scan(Genesys_Device* dev,
sanei_genesys_calculate_zmod(use_fast_fed,
scan_exposure_time * ccdlmt * tgtime,
scan_table.table,
scan_table.steps_count,
scan_table.table.size(),
feedl,
min_restep * step_multiplier,
&z1,
@ -436,11 +436,11 @@ static void gl847_init_motor_regs_scan(Genesys_Device* dev,
reg->set8(REG_0x67, REG_0x67_MTRPWM);
reg->set8(REG_0x68, REG_0x68_FASTPWM);
reg->set8(REG_STEPNO, scan_table.steps_count / step_multiplier);
reg->set8(REG_FASTNO, scan_table.steps_count / step_multiplier);
reg->set8(REG_FSHDEC, scan_table.steps_count / step_multiplier);
reg->set8(REG_FMOVNO, fast_table.steps_count / step_multiplier);
reg->set8(REG_FMOVDEC, fast_table.steps_count / step_multiplier);
reg->set8(REG_STEPNO, scan_table.table.size() / step_multiplier);
reg->set8(REG_FASTNO, scan_table.table.size() / step_multiplier);
reg->set8(REG_FSHDEC, scan_table.table.size() / step_multiplier);
reg->set8(REG_FMOVNO, fast_table.table.size() / step_multiplier);
reg->set8(REG_FMOVDEC, fast_table.table.size() / step_multiplier);
}

19
backend/genesys/motor.cpp
Wyświetl plik

@ -82,10 +82,18 @@ MotorSlope MotorSlope::create_from_steps(unsigned initial_w, unsigned max_w,
void MotorSlopeTable::slice_steps(unsigned count)
{
if (count >= table.size() || count > steps_count) {
throw SaneException("Excepssive steps count");
if (count > table.size()) {
throw SaneException("Excessive steps count");
}
steps_count = count;
table.resize(count);
}
void MotorSlopeTable::expand_table(unsigned count)
{
if (table.empty()) {
throw SaneException("Can't expand empty table");
}
table.resize(table.size() + count, table.back());
}
unsigned get_slope_table_max_size(AsicType asic_type)
@ -147,11 +155,6 @@ MotorSlopeTable create_slope_table_for_speed(const MotorSlope& slope, unsigned t
table.pixeltime_sum += table.table.back();
}
table.steps_count = table.table.size();
// fill the rest of the table with the final speed
table.table.resize(max_size, final_speed);
return table;
}

4
backend/genesys/motor.h
Wyświetl plik

@ -126,10 +126,12 @@ struct MotorSlope
struct MotorSlopeTable
{
std::vector<std::uint16_t> table;
unsigned steps_count = 0;
unsigned pixeltime_sum = 0;
void slice_steps(unsigned count);
// expands the table by the given number of steps
void expand_table(unsigned count);
};
unsigned get_slope_table_max_size(AsicType asic_type);

70
testsuite/backend/genesys/tests_motor.cpp
Wyświetl plik

@ -34,7 +34,6 @@ namespace genesys {
void test_create_slope_table3()
{
auto asic_type = AsicType::GL841;
auto max_table_size = get_slope_table_max_size(asic_type);
Genesys_Motor motor;
motor.id = MotorId::CANON_LIDE_200;
@ -48,80 +47,66 @@ void test_create_slope_table3()
motor.base_ydpi);
ASSERT_EQ(table.pixeltime_sum, 10000u);
ASSERT_EQ(table.steps_count, 1u);
ASSERT_EQ(table.table.size(), 1u);
std::vector<std::uint16_t> expected_steps = {
10000,
};
expected_steps.resize(max_table_size, 10000);
ASSERT_EQ(table.table, expected_steps);
table = sanei_genesys_create_slope_table3(asic_type, motor, StepType::FULL, 2000,
motor.base_ydpi);
ASSERT_EQ(table.pixeltime_sum, 33830u);
ASSERT_EQ(table.steps_count, 7u);
ASSERT_EQ(table.table.size(), 7u);
expected_steps = {
10000, 10000, 4099, 3028, 2511, 2192, 2000
};
expected_steps.resize(max_table_size, 2000);
ASSERT_EQ(table.table, expected_steps);
table = sanei_genesys_create_slope_table3(asic_type, motor, StepType::HALF, 10000,
motor.base_ydpi);
ASSERT_EQ(table.pixeltime_sum, 5000u);
ASSERT_EQ(table.steps_count, 1u);
ASSERT_EQ(table.table.size(), 1u);
expected_steps = {
5000,
};
expected_steps.resize(max_table_size, 5000);
ASSERT_EQ(table.table, expected_steps);
table = sanei_genesys_create_slope_table3(asic_type, motor, StepType::HALF, 2000,
motor.base_ydpi);
ASSERT_EQ(table.pixeltime_sum, 16914u);
ASSERT_EQ(table.steps_count, 7u);
ASSERT_EQ(table.table.size(), 7u);
expected_steps = {
5000, 5000, 2049, 1514, 1255, 1096, 1000
};
expected_steps.resize(max_table_size, 1000);
ASSERT_EQ(table.table, expected_steps);
table = sanei_genesys_create_slope_table3(asic_type, motor, StepType::QUARTER, 10000,
motor.base_ydpi);
ASSERT_EQ(table.pixeltime_sum, 2500u);
ASSERT_EQ(table.steps_count, 1u);
ASSERT_EQ(table.table.size(), 1u);
expected_steps = {
2500,
};
expected_steps.resize(max_table_size, 2500);
ASSERT_EQ(table.table, expected_steps);
table = sanei_genesys_create_slope_table3(asic_type, motor, StepType::QUARTER, 2000,
motor.base_ydpi);
ASSERT_EQ(table.pixeltime_sum, 7680u);
ASSERT_EQ(table.steps_count, 6u);
ASSERT_EQ(table.table.size(), 6u);
expected_steps = {
2500, 2500, 932, 683, 565, 500
};
expected_steps.resize(max_table_size, 500);
ASSERT_EQ(table.table, expected_steps);
}
@ -138,22 +123,20 @@ void test_create_slope_table_small_full_step()
auto table = create_slope_table_for_speed(slope, 5000, StepType::FULL, 4, 8, max_table_size);
std::vector<std::uint16_t> expected_table = {
62464, 62464, 6420, 5000
62464, 62464, 6420, 5000, 5000, 5000, 5000, 5000
};
expected_table.resize(max_table_size, 5000);
ASSERT_EQ(table.table, expected_table);
ASSERT_EQ(table.steps_count, 8u);
ASSERT_EQ(table.table.size(), 8u);
ASSERT_EQ(table.pixeltime_sum, 156348u);
table = create_slope_table_for_speed(slope, 3000, StepType::FULL, 4, 8, max_table_size);
expected_table = {
62464, 62464, 6420, 4552, 3720, 3223, 3000
62464, 62464, 6420, 4552, 3720, 3223, 3000, 3000
};
expected_table.resize(max_table_size, 3000);
ASSERT_EQ(table.table, expected_table);
ASSERT_EQ(table.steps_count, 8u);
ASSERT_EQ(table.table.size(), 8u);
ASSERT_EQ(table.pixeltime_sum, 148843u);
}
@ -172,9 +155,8 @@ void test_create_slope_table_small_full_step_target_speed_too_high()
std::vector<std::uint16_t> expected_table = {
62464, 62464, 6420, 4552, 3720, 3223, 2883, 2632
};
expected_table.resize(max_table_size, 2632);
ASSERT_EQ(table.table, expected_table);
ASSERT_EQ(table.steps_count, 8u);
ASSERT_EQ(table.table.size(), 8u);
ASSERT_EQ(table.pixeltime_sum, 148358u);
}
@ -191,22 +173,20 @@ void test_create_slope_table_small_half_step()
auto table = create_slope_table_for_speed(slope, 5000, StepType::HALF, 4, 8, max_table_size);
std::vector<std::uint16_t> expected_table = {
31232, 31232, 3210, 2500
31232, 31232, 3210, 2500, 2500, 2500, 2500, 2500
};
expected_table.resize(max_table_size, 2500);
ASSERT_EQ(table.table, expected_table);
ASSERT_EQ(table.steps_count, 8u);
ASSERT_EQ(table.table.size(), 8u);
ASSERT_EQ(table.pixeltime_sum, 78174u);
table = create_slope_table_for_speed(slope, 3000, StepType::HALF, 4, 8, max_table_size);
expected_table = {
31232, 31232, 3210, 2276, 1860, 1611, 1500
31232, 31232, 3210, 2276, 1860, 1611, 1500, 1500
};
expected_table.resize(max_table_size, 1500);
ASSERT_EQ(table.table, expected_table);
ASSERT_EQ(table.steps_count, 8u);
ASSERT_EQ(table.table.size(), 8u);
ASSERT_EQ(table.pixeltime_sum, 74421u);
}
@ -251,11 +231,10 @@ void test_create_slope_table_large_full_step()
5072, 4945, 4826, 4716, 4613, 4517, 4426, 4341, 4260, 4184,
4111, 4043, 3977, 3915, 3855, 3799, 3744, 3692, 3642, 3594,
3548, 3503, 3461, 3419, 3379, 3341, 3304, 3268, 3233, 3199,
3166, 3135, 3104, 3074, 3045, 3017, 3000,
3166, 3135, 3104, 3074, 3045, 3017, 3000, 3000, 3000, 3000,
};
expected_table.resize(max_table_size, 3000);
ASSERT_EQ(table.table, expected_table);
ASSERT_EQ(table.steps_count, 60u);
ASSERT_EQ(table.table.size(), 60u);
ASSERT_EQ(table.pixeltime_sum, 412616u);
@ -284,11 +263,10 @@ void test_create_slope_table_large_full_step()
1614, 1610, 1606, 1601, 1597, 1593, 1589, 1585, 1581, 1577,
1573, 1569, 1565, 1561, 1557, 1554, 1550, 1546, 1542, 1539,
1535, 1531, 1528, 1524, 1520, 1517, 1513, 1510, 1506, 1503,
1500,
1500, 1500, 1500, 1500,
};
expected_table.resize(max_table_size, 1500);
ASSERT_EQ(table.table, expected_table);
ASSERT_EQ(table.steps_count, 224u);
ASSERT_EQ(table.table.size(), 224u);
ASSERT_EQ(table.pixeltime_sum, 734910u);
}
@ -311,11 +289,10 @@ void test_create_slope_table_large_half_step()
2536, 2472, 2413, 2358, 2306, 2258, 2213, 2170, 2130, 2092,
2055, 2021, 1988, 1957, 1927, 1899, 1872, 1846, 1821, 1797,
1774, 1751, 1730, 1709, 1689, 1670, 1652, 1634, 1616, 1599,
1583, 1567, 1552, 1537, 1522, 1508, 1500,
1583, 1567, 1552, 1537, 1522, 1508, 1500, 1500, 1500, 1500,
};
expected_table.resize(max_table_size, 1500);
ASSERT_EQ(table.table, expected_table);
ASSERT_EQ(table.steps_count, 60u);
ASSERT_EQ(table.table.size(), 60u);
ASSERT_EQ(table.pixeltime_sum, 206294u);
@ -344,11 +321,10 @@ void test_create_slope_table_large_half_step()
807, 805, 803, 800, 798, 796, 794, 792, 790, 788,
786, 784, 782, 780, 778, 777, 775, 773, 771, 769,
767, 765, 764, 762, 760, 758, 756, 755, 753, 751,
750,
750, 750, 750, 750,
};
expected_table.resize(max_table_size, 750);
ASSERT_EQ(table.table, expected_table);
ASSERT_EQ(table.steps_count, 224u);
ASSERT_EQ(table.table.size(), 224u);
ASSERT_EQ(table.pixeltime_sum, 367399u);
}