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

genesys: Reduce duplication of *_feed() across different ASICs

merge-requests/213/head
Povilas Kanapickas 2019-12-01 10:08:54 +02:00
rodzic e435036b97
commit 052aa01626
10 zmienionych plików z 137 dodań i 354 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

7
backend/genesys/enums.h
Wyświetl plik

@ -498,6 +498,13 @@ inline bool has_flag(MotorFlag flags, MotorFlag which)
} }
enum class Direction : unsigned
{
FORWARD = 0,
BACKWARD = 1
};
} // namespace genesys } // namespace genesys
#endif // BACKEND_GENESYS_ENUMS_H #endif // BACKEND_GENESYS_ENUMS_H

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

@ -885,7 +885,6 @@ namespace gl847 {
} // namespace gl847 } // namespace gl847
namespace gl124 { namespace gl124 {
void gl124_feed(Genesys_Device* dev, unsigned int steps, int reverse);
void gl124_setup_scan_gpio(Genesys_Device* dev, int resolution); void gl124_setup_scan_gpio(Genesys_Device* dev, int resolution);
void gl124_stop_action(Genesys_Device* dev); void gl124_stop_action(Genesys_Device* dev);
} // namespace gl124 } // namespace gl124
@ -919,6 +918,36 @@ void scanner_clear_scan_and_feed_counts(Genesys_Device& dev)
} }
} }
void scanner_clear_scan_and_feed_counts2(Genesys_Device& dev)
{
// FIXME: switch to scanner_clear_scan_and_feed_counts when updating tests
switch (dev.model->asic_type) {
case AsicType::GL843: {
dev.interface->write_register(gl843::REG_0x0D, gl843::REG_0x0D_CLRLNCNT);
dev.interface->write_register(gl843::REG_0x0D, gl843::REG_0x0D_CLRMCNT);
break;
}
case AsicType::GL845:
case AsicType::GL846: {
dev.interface->write_register(gl846::REG_0x0D, gl846::REG_0x0D_CLRLNCNT);
dev.interface->write_register(gl846::REG_0x0D, gl846::REG_0x0D_CLRMCNT);
break;
}
case AsicType::GL847: {
dev.interface->write_register(gl847::REG_0x0D, gl847::REG_0x0D_CLRLNCNT);
dev.interface->write_register(gl847::REG_0x0D, gl847::REG_0x0D_CLRMCNT);
break;
}
case AsicType::GL124: {
dev.interface->write_register(gl124::REG_0x0D, gl124::REG_0x0D_CLRLNCNT);
dev.interface->write_register(gl124::REG_0x0D, gl124::REG_0x0D_CLRMCNT);
break;
}
default:
throw SaneException("Unsupported asic type");
}
}
void scanner_stop_action(Genesys_Device& dev) void scanner_stop_action(Genesys_Device& dev)
{ {
switch (dev.model->asic_type) { switch (dev.model->asic_type) {
@ -944,6 +973,92 @@ void scanner_stop_action(Genesys_Device& dev)
} }
} }
void scanner_move(Genesys_Device& dev, unsigned steps, Direction direction)
{
DBG_HELPER_ARGS(dbg, "steps=%d direction=%d", steps, static_cast<unsigned>(direction));
auto local_reg = dev.reg;
auto scan_method = dev.model->default_method;
unsigned resolution = dev.model->get_resolution_settings(scan_method).get_min_resolution_y();
const auto& sensor = sanei_genesys_find_sensor(&dev, resolution, 3, scan_method);
ScanSession session;
session.params.xres = resolution;
session.params.yres = resolution;
session.params.startx = 0;
session.params.starty = steps;
session.params.pixels = 100;
session.params.lines = 3;
session.params.depth = 8;
session.params.channels = 3;
session.params.scan_method = scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
if (dev.model->asic_type == AsicType::GL843) {
session.params.color_filter = ColorFilter::RED;
} else {
session.params.color_filter = dev.settings.color_filter;
}
session.params.flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::FEEDING |
ScanFlag::IGNORE_LINE_DISTANCE;
if (dev.model->asic_type == AsicType::GL124) {
session.params.flags |= ScanFlag::DISABLE_BUFFER_FULL_MOVE;
}
if (direction == Direction::BACKWARD) {
session.params.flags |= ScanFlag::REVERSE;
}
compute_session(&dev, session, sensor);
dev.cmd_set->init_regs_for_scan_session(&dev, sensor, &local_reg, session);
if (dev.model->asic_type != AsicType::GL843) {
regs_set_exposure(dev.model->asic_type, local_reg, {0, 0, 0});
}
scanner_clear_scan_and_feed_counts2(dev);
dev.interface->write_registers(local_reg);
try {
scanner_start_action(dev, true);
} catch (...) {
catch_all_exceptions(__func__, [&]() { scanner_stop_action(dev); });
// restore original registers
catch_all_exceptions(__func__, [&]() { dev.interface->write_registers(dev.reg); });
throw;
}
if (is_testing_mode()) {
dev.interface->test_checkpoint("feed");
// FIXME: why don't we stop the scanner like on other ASICs
if (dev.model->asic_type != AsicType::GL843) {
scanner_stop_action(dev);
}
return;
}
// wait until feed count reaches the required value
// FIXME: should porbably wait for some timeout
Status status;
do {
status = scanner_read_status(dev);
} while (!status.is_feeding_finished);
// FIXME: why don't we stop the scanner like on other ASICs
if (dev.model->asic_type != AsicType::GL843) {
scanner_stop_action(dev);
}
// looks like certain scanners lock up if we scan immediately after feeding
dev.interface->sleep_ms(100);
}
void scanner_slow_back_home(Genesys_Device& dev, bool wait_until_home) void scanner_slow_back_home(Genesys_Device& dev, bool wait_until_home)
{ {
DBG_HELPER_ARGS(dbg, "wait_until_home = %d", wait_until_home); DBG_HELPER_ARGS(dbg, "wait_until_home = %d", wait_until_home);
@ -980,8 +1095,8 @@ void scanner_slow_back_home(Genesys_Device& dev, bool wait_until_home)
} }
if (dev.model->model_id == ModelId::CANON_LIDE_210) { if (dev.model->model_id == ModelId::CANON_LIDE_210) {
// feed a little first // move the head back a little first
gl124::gl124_feed(&dev, 20, true); scanner_move(dev, 20, Direction::BACKWARD);
} }
Genesys_Register_Set local_reg = dev.reg; Genesys_Register_Set local_reg = dev.reg;

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

@ -1186,93 +1186,6 @@ void CommandSetGl124::slow_back_home_ta(Genesys_Device& dev) const
throw SaneException("not implemented"); throw SaneException("not implemented");
} }
/** @brief moves the slider to steps at motor base dpi
* @param dev device to work on
* @param steps number of steps to move
* @param reverse true is moving backward
* */
void gl124_feed(Genesys_Device* dev, unsigned int steps, int reverse)
{
DBG_HELPER_ARGS(dbg, "steps=%d", steps);
Genesys_Register_Set local_reg;
GenesysRegister *r;
/* prepare local registers */
local_reg = dev->reg;
unsigned resolution = sanei_genesys_get_lowest_ydpi(dev);
const auto& sensor = sanei_genesys_find_sensor(dev, resolution, 3, dev->model->default_method);
ScanSession session;
session.params.xres = resolution;
session.params.yres = resolution;
session.params.startx = 0;
session.params.starty = steps;
session.params.pixels = 100;
session.params.lines = 3;
session.params.depth = 8;
session.params.channels = 3;
session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter;
session.params.flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::FEEDING |
ScanFlag::DISABLE_BUFFER_FULL_MOVE |
ScanFlag::IGNORE_LINE_DISTANCE;
if (reverse) {
session.params.flags |= ScanFlag::REVERSE;
}
compute_session(dev, session, sensor);
dev->cmd_set->init_regs_for_scan_session(dev, sensor, &local_reg, session);
local_reg.set24(REG_EXPR, 0);
local_reg.set24(REG_EXPG, 0);
local_reg.set24(REG_EXPB, 0);
// clear scan and feed count
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRMCNT);
/* set up for no scan */
r = sanei_genesys_get_address (&local_reg, REG_0x01);
r->value &= ~REG_0x01_SCAN;
// send registers
dev->interface->write_registers(local_reg);
try {
scanner_start_action(*dev, true);
} catch (...) {
catch_all_exceptions(__func__, [&]() { gl124_stop_action (dev); });
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->interface->write_registers(dev->reg);
});
throw;
}
if (is_testing_mode()) {
dev->interface->test_checkpoint("feed");
gl124_stop_action(dev);
return;
}
// wait until feed count reaches the required value, but do not exceed 30s
Status status;
do {
status = scanner_read_status(*dev);
} while (!status.is_feeding_finished);
// then stop scanning
gl124_stop_action(dev);
}
// Automatically set top-left edge of the scan area by scanning a 200x200 pixels area at 600 dpi // Automatically set top-left edge of the scan area by scanning a 200x200 pixels area at 600 dpi
// from very top of scanner // from very top of scanner
void CommandSetGl124::search_start_position(Genesys_Device* dev) const void CommandSetGl124::search_start_position(Genesys_Device* dev) const
@ -1494,7 +1407,7 @@ void CommandSetGl124::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
DBG (DBG_info, "%s: move=%f steps\n", __func__, move); DBG (DBG_info, "%s: move=%f steps\n", __func__, move);
if (dev->settings.get_channels() * dev->settings.yres >= 600 && move > 700) { if (dev->settings.get_channels() * dev->settings.yres >= 600 && move > 700) {
gl124_feed(dev, static_cast<unsigned>(move - 500), false); scanner_move(*dev, static_cast<unsigned>(move - 500), Direction::FORWARD);
move=500; move=500;
} }
DBG(DBG_info, "%s: move=%f steps\n", __func__, move); DBG(DBG_info, "%s: move=%f steps\n", __func__, move);

2
backend/genesys/gl124.h
Wyświetl plik

@ -109,8 +109,6 @@ static Memory_layout layouts[]={
} }
}; };
void gl124_feed(Genesys_Device* dev, unsigned int steps, int reverse);
void gl124_stop_action(Genesys_Device* dev); void gl124_stop_action(Genesys_Device* dev);
static void gl124_send_slope_table(Genesys_Device* dev, int table_nr, static void gl124_send_slope_table(Genesys_Device* dev, int table_nr,

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

@ -1915,83 +1915,6 @@ void CommandSetGl843::init_regs_for_coarse_calibration(Genesys_Device* dev,
dev->interface->write_registers(regs); dev->interface->write_registers(regs);
} }
/** @brief moves the slider to steps at motor base dpi
* @param dev device to work on
* @param steps number of steps to move
* */
static void gl843_feed(Genesys_Device* dev, unsigned int steps)
{
DBG_HELPER(dbg);
Genesys_Register_Set local_reg;
GenesysRegister *r;
/* prepare local registers */
local_reg = dev->reg;
const auto& resolution_settings = dev->model->get_resolution_settings(dev->model->default_method);
unsigned resolution = resolution_settings.get_min_resolution_y();
const auto& sensor = sanei_genesys_find_sensor(dev, resolution, 3, dev->model->default_method);
ScanSession session;
session.params.xres = resolution;
session.params.yres = resolution;
session.params.startx = 0;
session.params.starty = steps;
session.params.pixels = 100;
session.params.lines = 3;
session.params.depth = 8;
session.params.channels = 3;
session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = ColorFilter::RED;
session.params.flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::FEEDING |
ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor);
dev->cmd_set->init_regs_for_scan_session(dev, sensor, &local_reg, session);
// clear scan and feed count
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRMCNT);
/* set up for no scan */
r = sanei_genesys_get_address(&local_reg, REG_0x01);
r->value &= ~REG_0x01_SCAN;
// send registers
dev->interface->write_registers(local_reg);
try {
scanner_start_action(*dev, true);
} catch (...) {
catch_all_exceptions(__func__, [&]() { gl843_stop_action(dev); });
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->interface->write_registers(dev->reg);
});
throw;
}
if (is_testing_mode()) {
dev->interface->test_checkpoint("feed");
// FIXME: other chips call *_stop_action()
return;
}
// wait until feed count reaches the required value, but do not exceed 30s
Status status;
do {
status = scanner_read_status(*dev);
} while (!status.is_feeding_finished);
// looks like the scanner locks up if we scan immediately after feeding
dev->interface->sleep_ms(100);
}
// init registers for shading calibration shading calibration is done at dpihw // init registers for shading calibration shading calibration is done at dpihw
void CommandSetGl843::init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor, void CommandSetGl843::init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const Genesys_Register_Set& regs) const
@ -2930,7 +2853,7 @@ void CommandSetGl843::asic_boot(Genesys_Device* dev, bool cold) const
// setup gpio // setup gpio
gl843_init_gpio(dev); gl843_init_gpio(dev);
gl843_feed (dev, 300); scanner_move(*dev, 300, Direction::FORWARD);
dev->interface->sleep_ms(100); dev->interface->sleep_ms(100);
} }
@ -2990,7 +2913,7 @@ void CommandSetGl843::move_to_ta(Genesys_Device* dev) const
} }
unsigned feed = static_cast<unsigned>(multiplier * (dev->model->y_offset_sensor_to_ta * resolution) / unsigned feed = static_cast<unsigned>(multiplier * (dev->model->y_offset_sensor_to_ta * resolution) /
MM_PER_INCH); MM_PER_INCH);
gl843_feed(dev, feed); scanner_move(*dev, feed, Direction::FORWARD);
} }

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

@ -1054,88 +1054,6 @@ void CommandSetGl846::init_regs_for_coarse_calibration(Genesys_Device* dev,
dev->interface->write_registers(regs); dev->interface->write_registers(regs);
} }
/** @brief moves the slider to steps at motor base dpi
* @param dev device to work on
* @param steps number of steps to move in base_dpi line count
* */
static void gl846_feed(Genesys_Device* dev, unsigned int steps)
{
DBG_HELPER_ARGS(dbg, "steps=%d\n", steps);
Genesys_Register_Set local_reg;
GenesysRegister *r;
/* prepare local registers */
local_reg = dev->reg;
unsigned resolution = sanei_genesys_get_lowest_ydpi(dev);
const auto& sensor = sanei_genesys_find_sensor(dev, resolution, 3, dev->model->default_method);
ScanSession session;
session.params.xres = resolution;
session.params.yres = resolution;
session.params.startx = 0;
session.params.starty = steps;
session.params.pixels = 100;
session.params.lines = 3;
session.params.depth = 8;
session.params.channels = 3;
session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter;
session.params.flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::FEEDING |
ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor);
dev->cmd_set->init_regs_for_scan_session(dev, sensor, &local_reg, session);
local_reg.set24(REG_EXPR, 0);
local_reg.set24(REG_EXPG, 0);
local_reg.set24(REG_EXPB, 0);
// clear scan and feed count
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRMCNT);
/* set up for no scan */
r = sanei_genesys_get_address(&local_reg, REG_0x01);
r->value &= ~REG_0x01_SCAN;
// send registers
dev->interface->write_registers(local_reg);
try {
scanner_start_action(*dev, true);
} catch (...) {
try {
gl846_stop_action(dev);
} catch (...) {}
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->interface->write_registers(dev->reg);
});
throw;
}
if (is_testing_mode()) {
dev->interface->test_checkpoint("feed");
gl846_stop_action(dev);
return;
}
// wait until feed count reaches the required value, but do not exceed 30s
Status status;
do {
status = scanner_read_status(*dev);
} while (!status.is_feeding_finished);
// then stop scanning
gl846_stop_action(dev);
}
// init registers for shading calibration // init registers for shading calibration
void CommandSetGl846::init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor, void CommandSetGl846::init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const Genesys_Register_Set& regs) const
@ -1234,9 +1152,8 @@ void CommandSetGl846::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
* computing acceleration/deceleration distance for scan * computing acceleration/deceleration distance for scan
* resolution. So leave a remainder for it so scan makes the final * resolution. So leave a remainder for it so scan makes the final
* move tuning */ * move tuning */
if (dev->settings.get_channels() * dev->settings.yres >= 600 && move > 700) if (dev->settings.get_channels() * dev->settings.yres >= 600 && move > 700) {
{ scanner_move(*dev, static_cast<unsigned>(move - 500), Direction::FORWARD);
gl846_feed(dev, static_cast<unsigned>(move - 500));
move=500; move=500;
} }
@ -1370,7 +1287,7 @@ SensorExposure CommandSetGl846::led_calibration(Genesys_Device* dev, const Genes
move = static_cast<float>((move * (dev->motor.base_ydpi / 4)) / MM_PER_INCH); move = static_cast<float>((move * (dev->motor.base_ydpi / 4)) / MM_PER_INCH);
if(move>20) if(move>20)
{ {
gl846_feed(dev, static_cast<unsigned>(move)); scanner_move(*dev, static_cast<unsigned>(move), Direction::FORWARD);
} }
DBG(DBG_io, "%s: move=%f steps\n", __func__, move); DBG(DBG_io, "%s: move=%f steps\n", __func__, move);

6
backend/genesys/gl846.h
Wyświetl plik

@ -50,12 +50,6 @@
namespace genesys { namespace genesys {
namespace gl846 { namespace gl846 {
/** @brief moves the slider to steps at motor base dpi
* @param dev device to work on
* @param steps number of steps to move
* */
static void gl846_feed(Genesys_Device* dev, unsigned int steps);
void gl846_stop_action(Genesys_Device* dev); void gl846_stop_action(Genesys_Device* dev);

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

@ -1100,86 +1100,6 @@ void CommandSetGl847::init_regs_for_coarse_calibration(Genesys_Device* dev,
dev->interface->write_registers(regs); dev->interface->write_registers(regs);
} }
/** @brief moves the slider to steps at motor base dpi
* @param dev device to work on
* @param steps number of steps to move in base_dpi line count
* */
static void gl847_feed(Genesys_Device* dev, unsigned int steps)
{
DBG_HELPER_ARGS(dbg, "steps=%d", steps);
Genesys_Register_Set local_reg;
GenesysRegister *r;
local_reg = dev->reg;
unsigned resolution = sanei_genesys_get_lowest_ydpi(dev);
const auto& sensor = sanei_genesys_find_sensor(dev, resolution, 3, dev->model->default_method);
ScanSession session;
session.params.xres = resolution;
session.params.yres = resolution;
session.params.startx = 0;
session.params.starty = steps;
session.params.pixels = 100;
session.params.lines = 3;
session.params.depth = 8;
session.params.channels = 3;
session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = ScanColorMode::COLOR_SINGLE_PASS;
session.params.color_filter = dev->settings.color_filter;
session.params.flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::FEEDING |
ScanFlag::IGNORE_LINE_DISTANCE;
compute_session(dev, session, sensor);
dev->cmd_set->init_regs_for_scan_session(dev, sensor, &local_reg, session);
// set exposure to zero
local_reg.set24(REG_EXPR,0);
local_reg.set24(REG_EXPG,0);
local_reg.set24(REG_EXPB,0);
// clear scan and feed count
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRMCNT);
/* set up for no scan */
r = sanei_genesys_get_address(&local_reg, REG_0x01);
r->value &= ~REG_0x01_SCAN;
// send registers
dev->interface->write_registers(local_reg);
try {
scanner_start_action(*dev, true);
} catch (...) {
catch_all_exceptions(__func__, [&]() { gl847_stop_action(dev); });
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->interface->write_registers(dev->reg);
});
throw;
}
if (is_testing_mode()) {
dev->interface->test_checkpoint("feed");
gl847_stop_action(dev);
return;
}
// wait until feed count reaches the required value, but do not exceed 30s
Status status;
do {
status = scanner_read_status(*dev);
} while (!status.is_feeding_finished);
// then stop scanning
gl847_stop_action(dev);
}
// init registers for shading calibration // init registers for shading calibration
void CommandSetGl847::init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor, void CommandSetGl847::init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const Genesys_Register_Set& regs) const
@ -1270,7 +1190,7 @@ void CommandSetGl847::init_regs_for_scan(Genesys_Device* dev, const Genesys_Sens
* resolution. So leave a remainder for it so scan makes the final * resolution. So leave a remainder for it so scan makes the final
* move tuning */ * move tuning */
if (dev->settings.get_channels() * dev->settings.yres >= 600 && move > 700) { if (dev->settings.get_channels() * dev->settings.yres >= 600 && move > 700) {
gl847_feed(dev, static_cast<unsigned>(move - 500)); scanner_move(*dev, static_cast<unsigned>(move - 500), Direction::FORWARD);
move=500; move=500;
} }
@ -1403,9 +1323,8 @@ SensorExposure CommandSetGl847::led_calibration(Genesys_Device* dev, const Genes
move = static_cast<float>(dev->model->y_offset_calib_white); move = static_cast<float>(dev->model->y_offset_calib_white);
move = static_cast<float>((move * (dev->motor.base_ydpi / 4)) / MM_PER_INCH); move = static_cast<float>((move * (dev->motor.base_ydpi / 4)) / MM_PER_INCH);
if(move>20) if (move > 20) {
{ scanner_move(*dev, static_cast<unsigned>(move), Direction::FORWARD);
gl847_feed(dev, static_cast<unsigned>(move));
} }
DBG(DBG_io, "%s: move=%f steps\n", __func__, move); DBG(DBG_io, "%s: move=%f steps\n", __func__, move);

6
backend/genesys/gl847.h
Wyświetl plik

@ -50,12 +50,6 @@
namespace genesys { namespace genesys {
namespace gl847 { namespace gl847 {
/** @brief moves the slider to steps at motor base dpi
* @param dev device to work on
* @param steps number of steps to move
* */
static void gl847_feed(Genesys_Device* dev, unsigned int steps);
typedef struct typedef struct
{ {
GpioId gpio_id; GpioId gpio_id;

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

@ -352,6 +352,9 @@ extern void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Se
const uint8_t* src_data, int start_pixel, int dpi, const uint8_t* src_data, int start_pixel, int dpi,
int width, int height); int width, int height);
// moves the scan head by the specified steps at the motor base dpi
void scanner_move(Genesys_Device& dev, unsigned steps, Direction direction);
void scanner_slow_back_home(Genesys_Device& dev, bool wait_until_home); void scanner_slow_back_home(Genesys_Device& dev, bool wait_until_home);
void scanner_clear_scan_and_feed_counts(Genesys_Device& dev); void scanner_clear_scan_and_feed_counts(Genesys_Device& dev);