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

genesys: Return MotorSlopeTable out of *_create_slope_table3()

merge-requests/213/head
Povilas Kanapickas 2019-12-14 10:20:07 +02:00
rodzic 7c6229f272
commit 8731a6cc5d
7 zmienionych plików z 141 dodań i 175 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

48
backend/genesys/genesys.cpp
Wyświetl plik

@ -439,17 +439,15 @@ SANE_Int sanei_genesys_generate_slope_table(std::vector<uint16_t>& slope_table,
* @return Time for acceleration
* @note all times in pixel time
*/
SANE_Int sanei_genesys_create_slope_table3(const Genesys_Motor& motor,
std::vector<uint16_t>& slope_table,
int max_step,
unsigned int use_steps,
StepType step_type,
int exposure_time,
unsigned yres,
unsigned int *used_steps,
unsigned int *final_exposure)
MotorSlopeTable sanei_genesys_create_slope_table3(const Genesys_Motor& motor,
unsigned max_steps,
unsigned use_steps,
StepType step_type,
int exposure_time,
unsigned yres)
{
unsigned int sum_time = 0;
MotorSlopeTable table;
unsigned int vtarget;
unsigned int vend;
unsigned int vstart;
@ -471,24 +469,22 @@ SANE_Int sanei_genesys_create_slope_table3(const Genesys_Motor& motor,
vstart = std::min(vstart >> u_step_type, 65535u);
vend = std::min(vend >> u_step_type, 65535u);
sum_time = sanei_genesys_generate_slope_table (slope_table,
max_step,
use_steps,
vtarget,
vstart,
vend,
slope.minimum_steps << u_step_type,
slope.g,
used_steps,
&vfinal);
unsigned used_steps = 0;
table.pixeltime_sum = sanei_genesys_generate_slope_table(table.table,
max_steps,
use_steps,
vtarget,
vstart,
vend,
slope.minimum_steps << u_step_type,
slope.g,
&used_steps,
&vfinal);
if (final_exposure) {
*final_exposure = (vfinal * motor.base_ydpi) / yres;
}
table.steps_count = used_steps;
table.final_exposure = (vfinal * motor.base_ydpi) / yres;
DBG(DBG_proc, "%s: returns sum_time=%d, completed\n", __func__, sum_time);
return sum_time;
return table;
}
/** @brief computes gamma table

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

@ -831,23 +831,23 @@ static void gl841_init_motor_regs(Genesys_Device* dev, const Genesys_Sensor& sen
static_cast<unsigned>(flags));
unsigned int fast_exposure = 0;
int use_fast_fed = 0;
std::vector<uint16_t> fast_slope_table;
unsigned int fast_slope_steps = 0;
unsigned int feedl;
GenesysRegister* r;
/*number of scan lines to add in a scan_lines line*/
fast_slope_table.resize(256, 0xffff);
{
std::vector<uint16_t> table;
table.resize(256, 0xffff);
gl841_send_slope_table(dev, 0, fast_slope_table, 256);
gl841_send_slope_table(dev, 1, fast_slope_table, 256);
gl841_send_slope_table(dev, 2, fast_slope_table, 256);
gl841_send_slope_table(dev, 3, fast_slope_table, 256);
gl841_send_slope_table(dev, 4, fast_slope_table, 256);
gl841_send_slope_table(dev, 0, table, 256);
gl841_send_slope_table(dev, 1, table, 256);
gl841_send_slope_table(dev, 2, table, 256);
gl841_send_slope_table(dev, 3, table, 256);
gl841_send_slope_table(dev, 4, table, 256);
}
gl841_write_freq(dev, dev->motor.base_ydpi / 4);
fast_slope_steps = 256;
if (action == MOTOR_ACTION_FEED || action == MOTOR_ACTION_GO_HOME) {
/* FEED and GO_HOME can use fastest slopes available */
fast_exposure = gl841_exposure_time(dev, sensor,
@ -863,17 +863,10 @@ static void gl841_init_motor_regs(Genesys_Device* dev, const Genesys_Sensor& sen
fast_exposure = dev->motor.get_slope(StepType::FULL).legacy().maximum_start_speed;
}
sanei_genesys_create_slope_table3(dev->motor,
fast_slope_table,
256,
fast_slope_steps,
StepType::FULL,
fast_exposure,
dev->motor.base_ydpi / 4,
&fast_slope_steps,
&fast_exposure);
auto fast_table = sanei_genesys_create_slope_table3(dev->motor, 256, 256, StepType::FULL,
fast_exposure, dev->motor.base_ydpi / 4);
feedl = feed_steps - fast_slope_steps*2;
feedl = feed_steps - fast_table.steps_count * 2;
use_fast_fed = 1;
/* all needed slopes available. we did even decide which mode to use.
@ -950,7 +943,7 @@ HOME_FREE: 3
r->value |= REG_0x02_MTRREV;
}
gl841_send_slope_table(dev, 3, fast_slope_table, 256);
gl841_send_slope_table(dev, 3, fast_table.table, 256);
r = sanei_genesys_get_address(reg, 0x67);
r->value = 0x3f;
@ -968,10 +961,10 @@ HOME_FREE: 3
r->value = 0;
r = sanei_genesys_get_address(reg, 0x6a);
r->value = (fast_slope_steps >> 1) + (fast_slope_steps & 1);
r->value = (fast_table.steps_count >> 1) + (fast_table.steps_count & 1);
r = sanei_genesys_get_address(reg, 0x5f);
r->value = (fast_slope_steps >> 1) + (fast_slope_steps & 1);
r->value = (fast_table.steps_count >> 1) + (fast_table.steps_count & 1);
}
static void gl841_init_motor_regs_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
@ -994,14 +987,6 @@ static void gl841_init_motor_regs_scan(Genesys_Device* dev, const Genesys_Sensor
int use_fast_fed = 0;
unsigned int fast_time;
unsigned int slow_time;
std::vector<uint16_t> slow_slope_table;
std::vector<uint16_t> fast_slope_table;
std::vector<uint16_t> back_slope_table;
unsigned int slow_slope_time;
unsigned int fast_slope_time;
unsigned int slow_slope_steps = 0;
unsigned int fast_slope_steps = 0;
unsigned int back_slope_steps = 0;
unsigned int feedl;
GenesysRegister* r;
unsigned int min_restep = 0x20;
@ -1015,13 +1000,17 @@ static void gl841_init_motor_regs_scan(Genesys_Device* dev, const Genesys_Sensor
DBG(DBG_info, "%s : fast_exposure=%d pixels\n", __func__, fast_exposure);
slow_slope_table.resize(256, 0xffff);
{
std::vector<uint16_t> table;
table.resize(256, 0xffff);
gl841_send_slope_table(dev, 0, table, 256);
gl841_send_slope_table(dev, 1, table, 256);
gl841_send_slope_table(dev, 2, table, 256);
gl841_send_slope_table(dev, 3, table, 256);
gl841_send_slope_table(dev, 4, table, 256);
}
gl841_send_slope_table(dev, 0, slow_slope_table, 256);
gl841_send_slope_table(dev, 1, slow_slope_table, 256);
gl841_send_slope_table(dev, 2, slow_slope_table, 256);
gl841_send_slope_table(dev, 3, slow_slope_table, 256);
gl841_send_slope_table(dev, 4, slow_slope_table, 256);
/* motor frequency table */
gl841_write_freq(dev, scan_yres);
@ -1031,50 +1020,36 @@ static void gl841_init_motor_regs_scan(Genesys_Device* dev, const Genesys_Sensor
how many steps we need for slow acceleration and how much steps we are
allowed to use.
*/
slow_slope_time = sanei_genesys_create_slope_table3(dev->motor,
slow_slope_table, 256,
256,
scan_step_type,
scan_exposure_time,
scan_yres,
&slow_slope_steps,
nullptr);
sanei_genesys_create_slope_table3(dev->motor,
back_slope_table, 256,
256,
scan_step_type,
0,
scan_yres,
&back_slope_steps,
nullptr);
auto slow_table = sanei_genesys_create_slope_table3(dev->motor, 256, 256, scan_step_type,
scan_exposure_time, scan_yres);
if (feed_steps < (slow_slope_steps >> static_cast<unsigned>(scan_step_type))) {
auto back_table = sanei_genesys_create_slope_table3(dev->motor, 256, 256, scan_step_type,
0, scan_yres);
if (feed_steps < (slow_table.steps_count >> static_cast<unsigned>(scan_step_type))) {
/*TODO: what should we do here?? go back to exposure calculation?*/
feed_steps = slow_slope_steps >> static_cast<unsigned>(scan_step_type);
feed_steps = slow_table.steps_count >> static_cast<unsigned>(scan_step_type);
}
if (feed_steps > fast_slope_steps*2 -
(slow_slope_steps >> static_cast<unsigned>(scan_step_type)))
unsigned max_fast_slope_steps = 0; // BUG: this should be 256 for the following conditional
// to make sense
if (feed_steps > max_fast_slope_steps * 2 -
(slow_table.steps_count >> static_cast<unsigned>(scan_step_type)))
{
fast_slope_steps = 256;
max_fast_slope_steps = 256;
} else {
// we need to shorten fast_slope_steps here.
fast_slope_steps = (feed_steps -
(slow_slope_steps >> static_cast<unsigned>(scan_step_type))) / 2;
max_fast_slope_steps = (feed_steps -
(slow_table.steps_count >> static_cast<unsigned>(scan_step_type))) / 2;
}
DBG(DBG_info, "%s: Maximum allowed slope steps for fast slope: %d\n", __func__,
fast_slope_steps);
max_fast_slope_steps);
fast_slope_time = sanei_genesys_create_slope_table3(dev->motor,
fast_slope_table, 256,
fast_slope_steps,
StepType::FULL,
fast_exposure,
dev->motor.base_ydpi / 4,
&fast_slope_steps,
&fast_exposure);
auto fast_table = sanei_genesys_create_slope_table3(dev->motor, 256, max_fast_slope_steps,
StepType::FULL, fast_exposure,
dev->motor.base_ydpi / 4);
/* fast fed special cases handling */
if (dev->model->gpio_id == GpioId::XP300
@ -1084,8 +1059,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_slope_steps * 2 +
(slow_slope_steps >> static_cast<unsigned>(scan_step_type)))
else if (feed_steps < fast_table.steps_count * 2 +
(slow_table.steps_count >> static_cast<unsigned>(scan_step_type)))
{
use_fast_fed = 0;
DBG(DBG_info, "%s: feed too short, slow move forced.\n", __func__);
@ -1100,13 +1075,13 @@ 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_slope_steps*2 -
(slow_slope_steps >> static_cast<unsigned>(scan_step_type)))
+ fast_slope_time*2 + slow_slope_time;
(feed_steps - fast_table.steps_count*2 -
(slow_table.steps_count >> static_cast<unsigned>(scan_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_slope_steps >> static_cast<unsigned>(scan_step_type)))
+ slow_slope_time;
(feed_steps - (slow_table.steps_count >> static_cast<unsigned>(scan_step_type)))
+ slow_table.pixeltime_sum;
DBG(DBG_info, "%s: Time for slow move: %d\n", __func__, slow_time);
DBG(DBG_info, "%s: Time for fast move: %d\n", __func__, fast_time);
@ -1115,12 +1090,12 @@ static void gl841_init_motor_regs_scan(Genesys_Device* dev, const Genesys_Sensor
}
if (use_fast_fed) {
feedl = feed_steps - fast_slope_steps * 2 -
(slow_slope_steps >> static_cast<unsigned>(scan_step_type));
} else if ((feed_steps << static_cast<unsigned>(scan_step_type)) < slow_slope_steps) {
feedl = feed_steps - fast_table.steps_count * 2 -
(slow_table.steps_count >> static_cast<unsigned>(scan_step_type));
} else if ((feed_steps << static_cast<unsigned>(scan_step_type)) < slow_table.steps_count) {
feedl = 0;
} else {
feedl = (feed_steps << static_cast<unsigned>(scan_step_type)) - slow_slope_steps;
feedl = (feed_steps << static_cast<unsigned>(scan_step_type)) - slow_table.steps_count;
}
DBG(DBG_info, "%s: Decided to use %s mode\n", __func__, use_fast_fed?"fast feed":"slow feed");
@ -1193,18 +1168,18 @@ HOME_FREE: 3
r->value &= ~0x40;
}
gl841_send_slope_table(dev, 0, slow_slope_table, 256);
gl841_send_slope_table(dev, 0, slow_table.table, 256);
gl841_send_slope_table(dev, 1, back_slope_table, 256);
gl841_send_slope_table(dev, 1, back_table.table, 256);
gl841_send_slope_table(dev, 2, slow_slope_table, 256);
gl841_send_slope_table(dev, 2, slow_table.table, 256);
if (use_fast_fed) {
gl841_send_slope_table(dev, 3, fast_slope_table, 256);
gl841_send_slope_table(dev, 3, fast_table.table, 256);
}
if (has_flag(flags, MotorFlag::AUTO_GO_HOME)) {
gl841_send_slope_table(dev, 4, fast_slope_table, 256);
gl841_send_slope_table(dev, 4, fast_table.table, 256);
}
/* now reg 0x21 and 0x24 are available, we can calculate reg 0x22 and 0x23,
@ -1213,17 +1188,19 @@ HOME_FREE: 3
2*STEPNO+FWDSTEP=2*FASTNO+BWDSTEP
*/
/* steps of table 0*/
if (min_restep < slow_slope_steps*2+2)
min_restep = slow_slope_steps*2+2;
if (min_restep < slow_table.steps_count * 2 + 2) {
min_restep = slow_table.steps_count * 2 + 2;
}
/* steps of table 1*/
if (min_restep < back_slope_steps*2+2)
min_restep = back_slope_steps*2+2;
if (min_restep < back_table.steps_count * 2 + 2) {
min_restep = back_table.steps_count * 2 + 2;
}
/* steps of table 0*/
r = sanei_genesys_get_address(reg, REG_FWDSTEP);
r->value = min_restep - slow_slope_steps*2;
r->value = min_restep - slow_table.steps_count*2;
/* steps of table 1*/
r = sanei_genesys_get_address(reg, REG_BWDSTEP);
r->value = min_restep - back_slope_steps*2;
r->value = min_restep - back_table.steps_count*2;
/*
for z1/z2:
@ -1268,19 +1245,19 @@ HOME_FREE: 3
r->value = 0x3f;
r = sanei_genesys_get_address(reg, REG_STEPNO);
r->value = (slow_slope_steps >> 1) + (slow_slope_steps & 1);
r->value = (slow_table.steps_count >> 1) + (slow_table.steps_count & 1);
r = sanei_genesys_get_address(reg, REG_FASTNO);
r->value = (back_slope_steps >> 1) + (back_slope_steps & 1);
r->value = (back_table.steps_count >> 1) + (back_table.steps_count & 1);
r = sanei_genesys_get_address (reg, 0x69);
r->value = (slow_slope_steps >> 1) + (slow_slope_steps & 1);
r->value = (slow_table.steps_count >> 1) + (slow_table.steps_count & 1);
r = sanei_genesys_get_address (reg, 0x6a);
r->value = (fast_slope_steps >> 1) + (fast_slope_steps & 1);
r->value = (fast_table.steps_count >> 1) + (fast_table.steps_count & 1);
r = sanei_genesys_get_address (reg, 0x5f);
r->value = (fast_slope_steps >> 1) + (fast_slope_steps & 1);
r->value = (fast_table.steps_count >> 1) + (fast_table.steps_count & 1);
}
static int

1
backend/genesys/low.cpp
Wyświetl plik

@ -1767,6 +1767,7 @@ MotorSlopeTable sanei_genesys_slope_table(int dpi, int exposure, int base_dpi,
auto table = create_slope_table(motor_profile.slope, target_speed_w, motor_profile.step_type,
factor, 2 * factor);
table.steps_count /= factor;
table.final_exposure = (table.final_exposure * base_dpi) / dpi;
return table;
}

13
backend/genesys/low.h
Wyświetl plik

@ -329,13 +329,12 @@ SANE_Int sanei_genesys_generate_slope_table(std::vector<uint16_t>& slope_table,
unsigned int steps, double g,
unsigned int *used_steps, unsigned int *vfinal);
SANE_Int sanei_genesys_create_slope_table3(const Genesys_Motor& motor,
std::vector<uint16_t>& slope_table, int max_step,
unsigned int use_steps,
StepType step_type, int exposure_time,
unsigned yres,
unsigned int *used_steps,
unsigned int *final_exposure);
MotorSlopeTable sanei_genesys_create_slope_table3(const Genesys_Motor& motor,
unsigned max_steps,
unsigned use_steps,
StepType step_type,
int exposure_time,
unsigned yres);
void sanei_genesys_create_default_gamma_table(Genesys_Device* dev,
std::vector<uint16_t>& gamma_table, float gamma);

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

@ -126,6 +126,8 @@ MotorSlopeTable create_slope_table(const MotorSlope& slope, unsigned target_spee
// fill the rest of the table with the final speed
table.table.resize(MotorSlopeTable::SLOPE_TABLE_SIZE, final_speed);
table.final_exposure = final_speed;
return table;
}

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

@ -151,6 +151,9 @@ struct MotorSlopeTable
std::vector<std::uint16_t> table;
unsigned steps_count = 0;
unsigned pixeltime_sum = 0;
// table.back() adjusted to the scan dpi
unsigned final_exposure = 0;
};
MotorSlopeTable create_slope_table(const MotorSlope& slope, unsigned target_speed_w,

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

@ -61,100 +61,88 @@ void test_create_slope_table3()
slope.g = 0.80f;
motor.slopes.push_back(slope);
unsigned used_steps = 0;
unsigned final_exposure = 0;
unsigned sum_time = 0;
std::vector<std::uint16_t> slope_table;
auto table = sanei_genesys_create_slope_table3(motor, 20, 20, StepType::FULL, 10000,
motor.base_ydpi);
sum_time = sanei_genesys_create_slope_table3(motor, slope_table, 20, 20, StepType::FULL,
10000, motor.base_ydpi, &used_steps,
&final_exposure);
ASSERT_EQ(sum_time, 10000u);
ASSERT_EQ(used_steps, 1u);
ASSERT_EQ(final_exposure, 10000u);
ASSERT_EQ(table.pixeltime_sum, 10000u);
ASSERT_EQ(table.steps_count, 1u);
ASSERT_EQ(table.final_exposure, 10000u);
std::vector<std::uint16_t> expected_steps = {
10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000,
10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000,
};
ASSERT_EQ(slope_table, expected_steps);
ASSERT_EQ(table.table, expected_steps);
sum_time = sanei_genesys_create_slope_table3(motor, slope_table, 20, 20, StepType::FULL,
2000, motor.base_ydpi, &used_steps,
&final_exposure);
table = sanei_genesys_create_slope_table3(motor, 20, 20, StepType::FULL, 2000, motor.base_ydpi);
ASSERT_EQ(sum_time, 98183u);
ASSERT_EQ(used_steps, 18u);
ASSERT_EQ(final_exposure, 1766u);
ASSERT_EQ(table.pixeltime_sum, 98183u);
ASSERT_EQ(table.steps_count, 18u);
ASSERT_EQ(table.final_exposure, 1766u);
expected_steps = {
10000, 9146, 8513, 7944, 7412, 6906, 6421, 5951, 5494, 5049,
4614, 4187, 3768, 3356, 2950, 2550, 2156, 1766, 1766, 1766,
};
ASSERT_EQ(slope_table, expected_steps);
ASSERT_EQ(table.table, expected_steps);
sum_time = sanei_genesys_create_slope_table3(motor, slope_table, 20, 20, StepType::HALF,
10000, motor.base_ydpi, &used_steps,
&final_exposure);
table = sanei_genesys_create_slope_table3(motor, 20, 20, StepType::HALF, 10000,
motor.base_ydpi);
ASSERT_EQ(sum_time, 5000u);
ASSERT_EQ(used_steps, 1u);
ASSERT_EQ(final_exposure, 5000u);
ASSERT_EQ(table.pixeltime_sum, 5000u);
ASSERT_EQ(table.steps_count, 1u);
ASSERT_EQ(table.final_exposure, 5000u);
expected_steps = {
5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000,
5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000,
};
ASSERT_EQ(slope_table, expected_steps);
ASSERT_EQ(table.table, expected_steps);
sum_time = sanei_genesys_create_slope_table3(motor, slope_table, 20, 20, StepType::HALF,
2000, motor.base_ydpi, &used_steps,
&final_exposure);
table = sanei_genesys_create_slope_table3(motor, 20, 20, StepType::HALF, 2000,
motor.base_ydpi);
ASSERT_EQ(sum_time, 72131u);
ASSERT_EQ(used_steps, 20u);
ASSERT_EQ(final_exposure, 2575u);
ASSERT_EQ(table.pixeltime_sum, 72131u);
ASSERT_EQ(table.steps_count, 20u);
ASSERT_EQ(table.final_exposure, 2575u);
expected_steps = {
5000, 4759, 4581, 4421, 4272, 4129, 3993, 3861, 3732, 3607,
3485, 3365, 3247, 3131, 3017, 2904, 2793, 2684, 2575, 2575,
};
ASSERT_EQ(slope_table, expected_steps);
ASSERT_EQ(table.table, expected_steps);
sum_time = sanei_genesys_create_slope_table3(motor, slope_table, 20, 20, StepType::QUARTER,
10000, motor.base_ydpi, &used_steps,
&final_exposure);
table = sanei_genesys_create_slope_table3(motor, 20, 20, StepType::QUARTER, 10000,
motor.base_ydpi);
ASSERT_EQ(sum_time, 2500u);
ASSERT_EQ(used_steps, 1u);
ASSERT_EQ(final_exposure, 2500u);
ASSERT_EQ(table.pixeltime_sum, 2500u);
ASSERT_EQ(table.steps_count, 1u);
ASSERT_EQ(table.final_exposure, 2500u);
expected_steps = {
2500, 2500, 2500, 2500, 2500, 2500, 2500, 2500, 2500, 2500,
2500, 2500, 2500, 2500, 2500, 2500, 2500, 2500, 2500, 2500,
};
ASSERT_EQ(slope_table, expected_steps);
ASSERT_EQ(table.table, expected_steps);
sum_time = sanei_genesys_create_slope_table3(motor, slope_table, 20, 20, StepType::QUARTER,
2000, motor.base_ydpi, &used_steps,
&final_exposure);
table = sanei_genesys_create_slope_table3(motor, 20, 20, StepType::QUARTER, 2000,
motor.base_ydpi);
ASSERT_EQ(sum_time, 40503u);
ASSERT_EQ(used_steps, 20u);
ASSERT_EQ(final_exposure, 1674u);
ASSERT_EQ(table.pixeltime_sum, 40503u);
ASSERT_EQ(table.steps_count, 20u);
ASSERT_EQ(table.final_exposure, 1674u);
expected_steps = {
2500, 2418, 2357, 2303, 2252, 2203, 2157, 2112, 2068, 2025,
1983, 1943, 1902, 1863, 1824, 1786, 1748, 1711, 1674, 1674,
};
ASSERT_EQ(slope_table, expected_steps);
ASSERT_EQ(table.table, expected_steps);
}
void test_create_slope_table_small_full_step()