project_boditech_vidas_a8000_v3
/
a8000_subboard
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

update PipetteModuleV2 related methods

master
zhaohe 8 months ago
parent
67a440b434
commit
460cf8d876
5 changed files with 49 additions and 411 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      a8000_protocol
  2. 406
      sdk/components/pipette_module/pipette_ctrl_module_v2.cpp
  3. 2
      sdk/components/pipette_module/pipette_ctrl_module_v2.hpp
  4. 43
      sdk/components/sensors/smtp2_v2/smtp2_v2.cpp
  5. 7
      sdk/components/sensors/smtp2_v2/smtp2_v2.hpp

2
a8000_protocol

@ -1 +1 @@
Subproject commit 70de85131a9ed15cbd296a887a180267b46fd114
Subproject commit ba614e601a4ec166fa2d6511f2fe0b4c14f60f85

406
sdk/components/pipette_module/pipette_ctrl_module_v2.cpp
View File

@ -145,7 +145,7 @@ int32_t PipetteModuleV2::module_xxx_reg_impl(int32_t param_id, bool read, int32_
/***********************************************************************************************************************
* STATE *
***********************************************************************************************************************/
XXX_STATE_REG(kreg_pipette_pos_ul, /* */ pump_read_pos_ul(&val));
XXX_STATE_REG(kreg_pipette_pos_nl, /* */ pump_read_pos_nl(&val));
XXX_STATE_REG(kreg_pipette_capactitance_val, /* */ pump_read_capactitance(&val));
XXX_STATE_REG(kreg_pipette_tip_state, /* */ pump_read_tip_state(&val));
XXX_STATE_REG(kreg_pipette_zm_pos, assign_int32(&val, zm_get_now_pos()));
@ -317,10 +317,10 @@ int32_t PipetteModuleV2::pipette_init_device() {
DO_IN_THREAD(m_smtp2.pump_init(m_cfg.pump_vmax));
pump_waitfor_stop();
m_smtp2.pump_set_io1_mode(0); // lld输入高
m_smtp2.pump_set_io2_mode(0); // 通用输入
m_smtp2.pump_set_tip_size(1); // 250ul
m_smtp2.pump_enable_temp_compensation(1); // 温度补偿
DO_IN_THREAD(m_smtp2.pump_set_io1_mode(0)); // lld输入高
DO_IN_THREAD(m_smtp2.pump_set_io2_mode(0)); // 通用输入
DO_IN_THREAD(m_smtp2.pump_set_tip_size(1)); // 250ul
DO_IN_THREAD(m_smtp2.pump_enable_temp_compensation(0)); // 温度补偿
//
// m_state.load_val_ul = 0;
@ -338,346 +338,10 @@ int32_t PipetteModuleV2::pipette_put_tip() {
});
return 0;
}
#if 0
int32_t PipetteModuleV2::pipette_lld_prepare() {
THREAD_START_WORK([this]() {
ZLOGI(TAG, "zmotor move to zero");
zm_move_to(0, m_cfg.zm_default_velocity);
zm_waitfor_stop();
int32_t tipstate = 0;
pump_read_tip_state(&tipstate);
if (tipstate != 0) {
ZLOGI(TAG, "pump move to 0 pos");
DO_IN_THREAD(m_smtp2.pump_move_to_ul(m_cfg.pump_vmax, 0)); // 移动到零点
pump_waitfor_stop();
}
ZLOGI(TAG, "pump move to 0");
DO_IN_THREAD(m_smtp2.pump_move_to_ul(m_cfg.pump_vmax, 0)); // 移动到中点
pump_waitfor_stop();
ZLOGI(TAG, "pump move to lld_prepare_pos %d", m_cfg.lld_prepare_pos);
DO_IN_THREAD(m_smtp2.pump_move_to_ul(m_cfg.pump_vmax, m_cfg.lld_prepare_pos)); // 移动到中点
pump_waitfor_stop();
m_state.lld_prepared = 1;
m_state.load_val_ul = 0;
});
return 0;
}
int32_t PipetteModuleV2::pipette_lld_test() { //
return do_pipette_lld(true, kplld, m_state.lld_startz, m_state.lld_endz - m_state.lld_startz, 100, 1000);
}
int32_t PipetteModuleV2::pipette_lld() { //
return do_pipette_lld(false, m_state.lld_type, m_state.lld_startz, m_state.lld_endz - m_state.lld_startz, m_state.lld_c_threshold, m_state.lld_p_threshold);
}
int32_t PipetteModuleV2::pipette_lld_is_detect_liquid(int32_t *detect) {
*detect = m_state.detected_liquid;
return 0;
}
int32_t PipetteModuleV2::pipette_aspirate_prepare() {
THREAD_START_WORK([this]() { //
ZLOGI(TAG, "pipette_aspirate_prepare");
m_state.load_val_ul = 0;
int32_t nowpos = zm_get_now_pos();
int32_t bak = nowpos - 200;
if (bak < 0) bak = 0;
zm_move_to(bak, m_cfg.zm_default_velocity);
zm_waitfor_stop();
// DO_IN_THREAD(m_smtp2.pump_move_to_ul(m_cfg.pump_vmax, 0));
// pump_waitfor_stop();
int32_t nowul;
DO_IN_THREAD(m_smtp2.pump_get_ul(&nowul));
if (nowul > ASPIRATE_POS) {
DO_IN_THREAD(m_smtp2.pump_move_to_ul(m_cfg.pump_vmax, ASPIRATE_POS));
pump_waitfor_stop();
}
zm_move_to(nowpos, m_cfg.zm_default_velocity);
zm_waitfor_stop();
ZLOGI(TAG, "pipette_aspirate_prepare end...");
});
return 0;
}
int32_t PipetteModuleV2::pipette_set_lld_startz(int32_t startz) {
ZLOGI(TAG, "pipette_set_lld_startz %d", startz);
m_state.lld_startz = startz;
return 0;
}
int32_t PipetteModuleV2::pipette_set_lld_endz(int32_t endz) {
ZLOGI(TAG, "pipette_set_lld_endz %d", endz);
m_state.lld_endz = endz;
return 0;
}
int32_t PipetteModuleV2::pipette_set_lld_type(int32_t lld_type) {
ZLOGI(TAG, "pipette_set_lld_type %d", lld_type);
m_state.lld_type = lld_type;
return 0;
}
int32_t PipetteModuleV2::pipette_set_lld_c_threshold(int32_t c_threshold) {
ZLOGI(TAG, "pipette_set_lld_c_threshold %d", c_threshold);
m_state.lld_c_threshold = c_threshold;
return 0;
}
int32_t PipetteModuleV2::pipette_set_lld_p_threshold(int32_t p_threshold) {
ZLOGI(TAG, "pipette_set_lld_p_threshold %d", p_threshold);
m_state.lld_p_threshold = p_threshold;
return 0;
}
int32_t PipetteModuleV2::pipette_set_llf_velocity(int32_t llf_zm_rpm) {
m_state.aspirate_cfg_llf_zm_rpm = llf_zm_rpm;
ZLOGI(TAG, "pipette_set_llf_velocity %d", llf_zm_rpm);
return 0;
}
int32_t PipetteModuleV2::pipette_set_llf_startz(int32_t startz) {
m_state.llf_startz = startz;
ZLOGI(TAG, "pipette_set_llf_startz %d", startz);
return 0;
}
int32_t PipetteModuleV2::pipette_set_llf_endz(int32_t endz) {
m_state.llf_endz = endz;
ZLOGI(TAG, "pipette_set_llf_end %d", endz);
return 0;
}
int32_t PipetteModuleV2::pipette_set_aspirate_operation_verifi_p_thre(int32_t p_thre) {
m_state.aspirate_cfg_p_thre = p_thre;
ZLOGI(TAG, "pipette_set_aspirate_operation_verifi_p_thre %d", p_thre);
return 0;
}
int32_t PipetteModuleV2::pipette_set_aspirate_operation_verifi_eigen_time(int32_t characteristic_time) {
m_state.aspirate_cfg_eigen_time = characteristic_time;
ZLOGI(TAG, "pipette_set_aspirate_operation_verifi_eigen_time %d", characteristic_time);
return 0;
}
int32_t PipetteModuleV2::pipette_set_aspirate_operation_verifi_tolerance(int32_t tolerance) {
m_state.aspirate_cfg_tolerance = tolerance;
ZLOGI(TAG, "pipette_set_aspirate_operation_verifi_tolerance %d", tolerance);
return 0;
}
int32_t PipetteModuleV2::pipette_aspirate(int32_t ul) {
// pipette_aspirate
if (m_state.load_val_ul + ul > m_cfg.limit_ul) {
ZLOGE(TAG, "pipette_aspirate %d fail , final ul (%d + %d)> limit ul %d", ul, m_state.load_val_ul, ul, m_cfg.limit_ul);
return err::kparam_out_of_range;
}
// llf_startz
// llf_endz
THREAD_START_WORK([this, ul]() {
m_state.lld_prepared = 0;
int dul = m_state.load_val_ul + ul <= 0 ? -m_state.load_val_ul : ul;
DO_IN_THREAD(m_smtp2.pump_aspirate(m_cfg.aspirate_pump_vel, dul));
// int32_t dpos = ul > 0 ? m_cfg.aspirate_zmotor_max_move_by : -m_cfg.aspirate_zmotor_max_move_by;
if (m_state.aspirate_cfg_llf_zm_rpm != 0) {
if (ul >= 0) {
zm_move_to(m_state.llf_endz, m_state.aspirate_cfg_llf_zm_rpm);
} else {
zm_move_to(m_state.llf_startz, m_state.aspirate_cfg_llf_zm_rpm);
}
}
pump_waitfor_stop();
// 全部排空时，多分配10ul去掉挂液
// if ((m_state.load_val_ul + dul) == 0) {
// m_smtp2.pump_move_to_ul(m_cfg.aspirate_pump_vel, 0);
// pump_waitfor_stop();
// // for (size_t i = 0; i < 3; i++) {
// // }
// }
// stop
m_zm->stop();
m_smtp2.pump_stop();
m_state.load_val_ul = m_state.load_val_ul + ul;
if (m_state.load_val_ul < 0) m_state.load_val_ul = 0;
});
return 0;
}
int32_t PipetteModuleV2::pipette_aspirate_and_verify(int32_t ul) {
if (m_state.load_val_ul + ul > m_cfg.limit_ul) {
ZLOGE(TAG, "pipette_aspirate %d fail , final ul (%d + %d)> limit ul %d", ul, m_state.load_val_ul, ul, m_cfg.limit_ul);
return err::kparam_out_of_range;
}
THREAD_START_WORK([this, ul]() {
m_state.lld_prepared = 0;
// zmotor and pump move
int dul = m_state.load_val_ul + ul <= 0 ? -m_state.load_val_ul : ul;
DO_IN_THREAD(m_smtp2.pump_aspirate_and_verify(m_cfg.aspirate_pump_vel, dul, //
m_state.aspirate_cfg_p_thre, //
m_state.aspirate_cfg_eigen_time, //
m_state.aspirate_cfg_tolerance));
// int32_t dpos = ul > 0 ? m_cfg.aspirate_zmotor_max_move_by : -m_cfg.aspirate_zmotor_max_move_by;
// if (m_state.aspirate_cfg_llf_zm_rpm != 0) zm_move_by(dpos, m_state.aspirate_cfg_llf_zm_rpm);
if (m_state.aspirate_cfg_llf_zm_rpm != 0) {
if (ul >= 0) {
zm_move_to(m_state.llf_endz, m_state.aspirate_cfg_llf_zm_rpm);
} else {
zm_move_to(m_state.llf_startz, m_state.aspirate_cfg_llf_zm_rpm);
}
}
// wait...
pump_waitfor_stop();
// stop
m_zm->stop();
m_smtp2.pump_stop();
m_state.load_val_ul = m_state.load_val_ul + ul;
if (m_state.load_val_ul < 0) m_state.load_val_ul = 0;
});
return 0;
}
int32_t PipetteModuleV2::pipette_clear_hanging_liquid(int32_t repeat_times) {
// llf_startz
// llf_endz
THREAD_START_WORK([this, repeat_times]() {
// 全部排空时，多分配10ul去掉挂液
m_smtp2.pump_move_to_ul(m_cfg.pump_vmax, 0);
pump_waitfor_stop();
m_state.load_val_ul = 0;
int32_t nowpos = zm_get_now_pos();
int32_t pos1 = nowpos - 100;
int32_t pos2 = nowpos - 10;
if (pos1 < 0) pos1 = 0;
if (pos2 < 0) pos2 = 0;
for (int i = 0; i < repeat_times; i++) {
zm_move_to(pos1, m_cfg.zm_default_velocity);
zm_waitfor_stop();
zm_move_to(pos2, m_cfg.zm_default_velocity);
zm_waitfor_stop();
}
});
return 0;
}
int32_t PipetteModuleV2::pipette_shake_up(int32_t ul, int32_t times) {
if (m_state.load_val_ul != 0) {
ZLOGE(TAG, "pipette_shake_up fail, load_val_ul %d != 0", m_state.load_val_ul);
return err::kpipette_error_pump_load_val_is_not_empty;
}
if (m_state.load_val_ul + ul > m_cfg.limit_ul) {
ZLOGE(TAG, "pipette_aspirate %d fail , final ul (%d + %d)> limit ul %d", ul, m_state.load_val_ul, ul, m_cfg.limit_ul);
return err::kparam_out_of_range;
}
THREAD_START_WORK([this, ul, times]() {
//
int32_t dpos = 0;
int32_t startpos = m_zm->getXACTUAL();
int32_t endpos = 0;
// first aspirate
// if (m_state.aspirate_cfg_llf_zm_rpm) zm_move_by(LLF_DPOS, m_state.aspirate_cfg_llf_zm_rpm);
if (m_state.aspirate_cfg_llf_zm_rpm != 0) {
zm_move_to(m_state.llf_endz, m_state.aspirate_cfg_llf_zm_rpm);
}
DO_IN_THREAD(m_smtp2.pump_aspirate(m_cfg.aspirate_pump_vel, ul));
pump_waitfor_stop();
m_zm->stop();
m_smtp2.pump_stop();
endpos = m_zm->getXACTUAL();
for (int i = 0; i < times - 1; i++) {
// distribute
if (m_state.aspirate_cfg_llf_zm_rpm) zm_move_to(startpos, m_state.aspirate_cfg_llf_zm_rpm);
DO_IN_THREAD(m_smtp2.pump_aspirate(m_cfg.aspirate_pump_vel, -ul));
pump_waitfor_stop();
zm_waitfor_stop();
// aspirate
if (m_state.aspirate_cfg_llf_zm_rpm) zm_move_to(endpos, m_state.aspirate_cfg_llf_zm_rpm);
DO_IN_THREAD(m_smtp2.pump_aspirate(m_cfg.aspirate_pump_vel, ul));
pump_waitfor_stop();
zm_waitfor_stop();
}
// final distribute
if (m_state.aspirate_cfg_llf_zm_rpm) zm_move_to(startpos, m_state.aspirate_cfg_llf_zm_rpm);
DO_IN_THREAD(m_smtp2.pump_aspirate(m_cfg.aspirate_pump_vel, -ul));
pump_waitfor_stop();
zm_waitfor_stop();
});
return 0;
}
int32_t PipetteModuleV2::pipette_aspirate_infer_pressure(int32_t ul) {
THREAD_START_WORK([this, ul]() {
//
ZLOGI(TAG, "pipette_aspirate_infer_pressure %d", ul);
m_asynchronous_result.result0 = 0;
DO_IN_THREAD(m_smtp2.pump_aspirate_infer_pressure(m_cfg.aspirate_pump_vel, ul));
pump_waitfor_stop();
m_smtp2.pump_get_infer_pressure(&m_asynchronous_result.result0);
ZLOGI(TAG, "pipette_aspirate_infer_pressure %d", m_asynchronous_result.result0);
});
return 0;
}
int32_t PipetteModuleV2::pipette_get_aspirate_infer_pressure_result(int32_t *result) {
*result = m_asynchronous_result.result0;
return 0;
}
int32_t PipetteModuleV2::pipette_aspirate_infer_eigen_time(int32_t ul) {
//
THREAD_START_WORK([this, ul]() {
//
ZLOGI(TAG, "pipette_aspirate_infer_eigen_time %d", ul);
m_asynchronous_result.result0 = 0;
DO_IN_THREAD(m_smtp2.pump_aspirate_infer_eigen_time(m_cfg.aspirate_pump_vel, ul));
//
while (true) {
ZLOGI(TAG, "wait for pump stop....");
int32_t isbusy = 0;
m_smtp2.pump_get_state(&isbusy); // PS: 这里不做错误检查的原因是，pump_aspirate_infer_eigen_time指令一定会触发错误
if (isbusy == 0) break;
thread_delay(100);
}
m_smtp2.pump_get_infer_eigen_time(&m_asynchronous_result.result0);
ZLOGI(TAG, "pipette_aspirate_infer_eigen_time %d", m_asynchronous_result.result0);
});
return 0;
}
int32_t PipetteModuleV2::pipette_get_aspirate_infer_eigen_time_result(int32_t *result) {
*result = m_asynchronous_result.result0;
return 0;
}
#endif
int32_t PipetteModuleV2::pipette_pump_move_to(int32_t pumpv, int32_t ul) {
THREAD_START_WORK([this, pumpv, ul]() {
DO_IN_THREAD(m_smtp2.pump_move_to_ul(pumpv, ul));
int32_t PipetteModuleV2::pipette_pump_move_to(int32_t pumpv, int32_t nl) {
THREAD_START_WORK([this, pumpv, nl]() {
DO_IN_THREAD(m_smtp2.pump_move_to_nl(pumpv, nl));
pump_waitfor_stop();
m_smtp2.pump_stop();
});
@ -777,15 +441,15 @@ int32_t PipetteModuleV2::pipette_lld_is_detect_liquid(int32_t *detect) {
return 0;
}
int32_t PipetteModuleV2::pipette_aspirate(int32_t llfrpm, int32_t llftpos, int32_t pumpv, int32_t ul) {
int32_t PipetteModuleV2::pipette_aspirate(int32_t llfrpm, int32_t llftpos, int32_t pumpv, int32_t nl) {
// pipette_aspirate
if (ul < 0) {
ZLOGE(TAG, "pipette_aspirate %d fail , ul < 0", ul);
if (nl < 0) {
ZLOGE(TAG, "pipette_aspirate %d fail , ul < 0", nl);
return err::kparam_out_of_range;
}
THREAD_START_WORK([this, llfrpm, llftpos, pumpv, ul]() {
DO_IN_THREAD(m_smtp2.pump_aspirate(pumpv, ul));
THREAD_START_WORK([this, llfrpm, llftpos, pumpv, nl]() {
DO_IN_THREAD(m_smtp2.pump_aspirate_nl(pumpv, nl));
if (llfrpm != 0) zm_move_to(llftpos, llfrpm);
@ -796,15 +460,15 @@ int32_t PipetteModuleV2::pipette_aspirate(int32_t llfrpm, int32_t llftpos, int32
});
return 0;
}
int32_t PipetteModuleV2::pipette_distribu(int32_t llfrpm, int32_t pumpv, int32_t ul) {
int32_t PipetteModuleV2::pipette_distribu(int32_t llfrpm, int32_t pumpv, int32_t nl) {
// pipette_aspirate
if (ul < 0) {
ZLOGE(TAG, "pipette_distribu %d fail , ul < 0", ul);
if (nl < 0) {
ZLOGE(TAG, "pipette_distribu %d fail , nl < 0", nl);
return err::kparam_out_of_range;
}
THREAD_START_WORK([this, llfrpm, pumpv, ul]() {
DO_IN_THREAD(m_smtp2.pump_aspirate(pumpv, -ul));
THREAD_START_WORK([this, llfrpm, pumpv, nl]() {
DO_IN_THREAD(m_smtp2.pump_aspirate_nl(pumpv, -nl));
if (llfrpm != 0) zm_move_to(0, llfrpm);
@ -815,18 +479,8 @@ int32_t PipetteModuleV2::pipette_distribu(int32_t llfrpm, int32_t pumpv, int32_t
});
return 0;
}
int32_t PipetteModuleV2::pipette_shake_up(int32_t llfrpm, int32_t maxzpos, int32_t pumpv, int32_t ul, int32_t times) {
// if (m_state.load_val_ul != 0) {
// ZLOGE(TAG, "pipette_shake_up fail, load_val_ul %d != 0", m_state.load_val_ul);
// return err::kpipette_error_pump_load_val_is_not_empty;
// }
// if (m_state.load_val_ul + ul > m_cfg.limit_ul) {
// ZLOGE(TAG, "pipette_aspirate %d fail , final ul (%d + %d)> limit ul %d", ul, m_state.load_val_ul, ul, m_cfg.limit_ul);
// return err::kparam_out_of_range;
// }
THREAD_START_WORK([this, llfrpm, maxzpos, pumpv, ul, times]() {
int32_t PipetteModuleV2::pipette_shake_up(int32_t llfrpm, int32_t maxzpos, int32_t pumpv, int32_t nl, int32_t times) {
THREAD_START_WORK([this, llfrpm, maxzpos, pumpv, nl, times]() {
//
int32_t dpos = 0;
@ -835,7 +489,7 @@ int32_t PipetteModuleV2::pipette_shake_up(int32_t llfrpm, int32_t maxzpos, int32
if (llfrpm != 0) zm_move_to(maxzpos, llfrpm);
DO_IN_THREAD(m_smtp2.pump_aspirate(pumpv, ul));
DO_IN_THREAD(m_smtp2.pump_aspirate_nl(pumpv, nl));
pump_waitfor_stop();
m_zm->stop();
m_smtp2.pump_stop();
@ -844,20 +498,20 @@ int32_t PipetteModuleV2::pipette_shake_up(int32_t llfrpm, int32_t maxzpos, int32
for (int i = 0; i < times - 1; i++) {
// distribute
if (llfrpm) zm_move_to(startpos, llfrpm);
DO_IN_THREAD(m_smtp2.pump_aspirate(pumpv, -ul));
DO_IN_THREAD(m_smtp2.pump_aspirate_nl(pumpv, -nl));
pump_waitfor_stop();
zm_waitfor_stop();
// aspirate
if (llfrpm) zm_move_to(endpos, llfrpm);
DO_IN_THREAD(m_smtp2.pump_aspirate(pumpv, ul));
DO_IN_THREAD(m_smtp2.pump_aspirate_nl(pumpv, nl));
pump_waitfor_stop();
zm_waitfor_stop();
}
// final distribute
if (llfrpm) zm_move_to(startpos, llfrpm);
DO_IN_THREAD(m_smtp2.pump_aspirate(pumpv, -ul));
DO_IN_THREAD(m_smtp2.pump_aspirate_nl(pumpv, -nl));
pump_waitfor_stop();
zm_waitfor_stop();
});
@ -869,13 +523,13 @@ int32_t PipetteModuleV2::pipette_clear_hanging_liquid(int32_t repeat_times) {
// llf_endz
THREAD_START_WORK([this, repeat_times]() {
for (int i = 0; i < repeat_times; i++) {
m_smtp2.pump_move_to_ul(m_cfg.pump_vmax, 0);
m_smtp2.pump_move_to_nl(m_cfg.pump_vmax, 0);
pump_waitfor_stop();
m_smtp2.pump_move_to_ul(m_cfg.pump_vmax, 50);
m_smtp2.pump_move_to_nl(m_cfg.pump_vmax, 100 * 1000);
pump_waitfor_stop();
}
m_smtp2.pump_move_to_ul(m_cfg.pump_vmax, 0);
m_smtp2.pump_move_to_nl(m_cfg.pump_vmax, 0);
pump_waitfor_stop();
});
return 0;
@ -1131,12 +785,12 @@ void PipetteModuleV2::pump_waitfor_stop() {
}
}
int32_t PipetteModuleV2::pump_read_pos_ul(int32_t *val) {
int32_t PipetteModuleV2::pump_read_pos_nl(int32_t *val) {
//
// *val = m_state.load_val_ul;
// *val = pum
// pump_read_pos_ul(val);
m_smtp2.pump_get_ul(val);
// pump_read_pos_nl(val);
m_smtp2.pump_get_nl(val);
return 0;
}
int32_t PipetteModuleV2::pump_read_capactitance(int32_t *val) {

2
sdk/components/pipette_module/pipette_ctrl_module_v2.hpp
View File

@ -212,7 +212,7 @@ class PipetteModuleV2 : public ZIModule {
void zm_waitfor_stop();
int32_t pump_read_pos_ul(int32_t *val);
int32_t pump_read_pos_nl(int32_t *val);
int32_t pump_read_capactitance(int32_t *val);
int32_t pump_read_tip_state(int32_t *val);
void pump_waitfor_stop();

43
sdk/components/sensors/smtp2_v2/smtp2_v2.cpp
View File

@ -57,12 +57,10 @@ int32_t SMTP2V2::pump_get_pressure(int32_t* pressure) { //
int32_t SMTP2V2::pump_get_tip_state(int32_t* tipison) { return pump_get_state_as_int(kstate_tip_state, tipison); }
int32_t SMTP2V2::pump_get_ul(int32_t* ul) {
int32_t nl = 0;
int32_t ret = pump_get_state_as_int(kstate_pump_pos_nl, &nl);
if (ret != 0) return ret;
int32_t SMTP2V2::pump_get_nl(int32_t* nl) {
*ul = nl / 1000.0 + 0.5;
int32_t ret = pump_get_state_as_int(kstate_pump_pos_nl, nl);
if (ret != 0) return ret;
return ret;
}
@ -109,38 +107,25 @@ static int32_t Get1fromfloat(const float& val) {
}
#endif
int32_t SMTP2V2::pump_move_to_ul(int32_t v, int32_t ul) {
/**
* @brief 分辨率在0.319ul进行操作
*
* 模式0: 0...3143
*
* ul:0->1000
*/
ZLOGI(TAG, "pump_move_to_ul %d", ul);
int stepNum = ul * 1000; //+0.5 是为了浮点数强转成正数时采用四舍五入的方式
return pump_move_to_nl(v, ul * 1000);
}
int32_t SMTP2V2::pump_move_to_nl(int32_t v, int32_t nl) {
ZLOGI(TAG, "pump_move_to_nl %d", nl);
return runaction(true, "/1V%dA%dR\r", v * 319, nl);
}
int32_t SMTP2V2::pump_aspirate(int32_t v, int32_t ul) {
ZLOGI(TAG, "pump_aspirate %d", ul);
int32_t SMTP2V2::pump_aspirate_nl(int32_t v, int32_t nl) {
ZLOGI(TAG, "pump_aspirate %d", nl);
int32_t nownl;
int32_t ret = pump_get_state_as_int(kstate_pump_pos_nl, &nownl);
if (ret != 0) return ret;
int targetnl = nownl + ul * 1000;
int targetnl = nownl + nl;
if (targetnl < 0) targetnl = 0;
return pump_move_to_nl(v, targetnl);
}
int32_t SMTP2V2::pump_distribut(int32_t v, int32_t ul) { return pump_aspirate(v, -ul); }
int32_t SMTP2V2::pump_distribut_all(int32_t v) { return pump_aspirate(v, -1000); }
int32_t SMTP2V2::pump_distribut_nl(int32_t v, int32_t nl) { return pump_aspirate_nl(v, -nl); }
int32_t SMTP2V2::pump_distribut_all(int32_t v) { return pump_aspirate_nl(v, -1000 * 1000); }
// int32_t SMTP2V2::pump_distribut(int32_t v, int32_t ul) {
// ZLOGI(TAG, "pump_distribut %d", ul);
@ -155,7 +140,7 @@ int32_t SMTP2V2::pump_distribut_all(int32_t v) { return pump_aspirate(v, -1000);
// return pump_move_to_nl(v, targetnl);
// }
int32_t SMTP2V2::pump_aspirate_and_verify(int32_t v, int32_t ul, int32_t eigen_time, int32_t p_thre, int32_t tolerance) {
int32_t SMTP2V2::pump_aspirate_and_verify(int32_t v, int32_t nl, int32_t eigen_time, int32_t p_thre, int32_t tolerance) {
/**
* @brief
* p_thro 压力阈值
@ -166,27 +151,27 @@ int32_t SMTP2V2::pump_aspirate_and_verify(int32_t v, int32_t ul, int32_t eigen_t
* <n2> 0…2047 压力阈值，用于识别堵塞的Tip
*
*/
ZLOGI(TAG, "pump_aspirate %d", ul);
ZLOGI(TAG, "pump_aspirate %d", nl);
int32_t nownl;
int32_t ret = pump_get_state_as_int(kstate_pump_pos_nl, &nownl);
if (ret != 0) return ret;
int targetnl = nownl + ul * 1000;
int targetnl = nownl + nl;
if (targetnl < 0) targetnl = 0;
return runaction(true, "/1%%%dq%d,%dV%dA%dR\r", tolerance, eigen_time, p_thre, v * 319, targetnl);
}
int32_t SMTP2V2::pump_aspirate_infer_pressure(int32_t v, int32_t ul) {
int32_t SMTP2V2::pump_aspirate_infer_pressure(int32_t v, int32_t nl) {
// V2000f1A600f0R
ZLOGI(TAG, "pump_aspirate_infer_pressure %d", ul);
ZLOGI(TAG, "pump_aspirate_infer_pressure %d", nl);
int32_t nownl;
int32_t ret = pump_get_state_as_int(kstate_pump_pos_nl, &nownl);
if (ret != 0) return ret;
int targetnl = nownl + ul * 1000;
int targetnl = nownl + nl;
if (targetnl < 0) targetnl = 0;
return runaction(true, "/1V%df1A%df0R\r", v * 319, targetnl);
}

7
sdk/components/sensors/smtp2_v2/smtp2_v2.hpp
View File

@ -165,7 +165,7 @@ class SMTP2V2 {
int32_t pump_get_capacitance(int32_t* capacitance);
int32_t pump_get_pressure(int32_t* pressure);
int32_t pump_get_tip_state(int32_t* tipison);
int32_t pump_get_ul(int32_t* ul);
int32_t pump_get_nl(int32_t* nl);
int32_t pump_get_state_as_int(int32_t state_index, int32_t* val);
@ -192,7 +192,6 @@ class SMTP2V2 {
int32_t pump_reset(); // 泵机复位
int32_t pump_stop(); // 停止
int32_t pump_put_tip(); // 丢弃TIP
int32_t pump_move_to_ul(int32_t v, int32_t ul); //
int32_t pump_move_to_nl(int32_t v, int32_t nl); //
@ -205,8 +204,8 @@ class SMTP2V2 {
int32_t pump_distribut_mlld(int32_t pumpv, int32_t c_threshold, int32_t pressure_threshold); //
int32_t pump_distribut_mlld_get_state(int32_t* detected);
int32_t pump_aspirate(int32_t v, int32_t ul);
int32_t pump_distribut(int32_t v, int32_t ul);
int32_t pump_aspirate_nl(int32_t v, int32_t nl);
int32_t pump_distribut_nl(int32_t v, int32_t nl);
int32_t pump_distribut_all(int32_t v);
int32_t pump_aspirate_and_verify(int32_t v, int32_t ul, int32_t eigen_time, int32_t p_thre, int32_t tolerance);

Write Preview
Loading…
Cancel
Save