调整状态机扩展性，新增 串口通信协议，新增寄存器框架，微调处理 3通达CIS
This commit is contained in:
modehua
parent
ac26e428dc
commit
f38c5b9f9f
|
|
@ -21,6 +21,15 @@ union CamZ_Reg_2char
|
|||
int value;
|
||||
};
|
||||
|
||||
union test2
|
||||
{
|
||||
int value;
|
||||
struct tests
|
||||
{
|
||||
uint8_t data1:8;
|
||||
uint8_t data2:8;
|
||||
}bit;
|
||||
};
|
||||
union CamZ_Reg_4
|
||||
{
|
||||
int value;
|
||||
|
|
|
|||
|
|
@ -26,9 +26,9 @@ void CuoZhiMotor::pauseWaitForThread()
|
|||
if (thStart.joinable())
|
||||
{
|
||||
thStart.join();
|
||||
}
|
||||
pause();
|
||||
}
|
||||
}
|
||||
|
||||
void CuoZhiMotor::startAsyn()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ void FsmState::SetLedStatus(LedStatus s)
|
|||
}
|
||||
std::map<std::string, std::shared_ptr<FsmState>> FsmStateManager::fsmStates;
|
||||
|
||||
void NoPaperState::initial()
|
||||
void NoPaperState::initial(void *data)
|
||||
{
|
||||
printf("FSM: 扫描仪 无纸\n");
|
||||
SetLedStatus(LedStatus::Ready);
|
||||
|
|
@ -30,8 +30,7 @@ FsmState *NoPaperState::on_event(ScanEvent &event)
|
|||
return scanner->test(event);
|
||||
}
|
||||
|
||||
|
||||
void PaperReadyState::initial()
|
||||
void PaperReadyState::initial(void *data)
|
||||
{
|
||||
if (scanner->getSensor().isPaperIn())
|
||||
{
|
||||
|
|
@ -46,7 +45,7 @@ FsmState *PaperReadyState::on_event(ScanEvent &event)
|
|||
return scanner->test(event);
|
||||
}
|
||||
|
||||
void CoverCloseState::initial()
|
||||
void CoverCloseState::initial(void *data)
|
||||
{
|
||||
if (scanner->getSensor().isPaperIn())
|
||||
{
|
||||
|
|
@ -69,7 +68,7 @@ FsmState *CoverCloseState::on_event(ScanEvent &event)
|
|||
return scanner->test(event);
|
||||
}
|
||||
|
||||
void CoverOpenState::initial()
|
||||
void CoverOpenState::initial(void *data)
|
||||
{
|
||||
printf("FSM: 扫描仪 开盖\n");
|
||||
scanner->put(HG_EVT_STOP_SCAN_EMERGENCY);
|
||||
|
|
@ -80,7 +79,7 @@ FsmState *CoverOpenState::on_event(ScanEvent &event)
|
|||
return scanner->test(event);
|
||||
}
|
||||
|
||||
void Boundary_Detection_State::initial()
|
||||
void Boundary_Detection_State::initial(void *data)
|
||||
{
|
||||
printf("FSM: 扫描仪 纸张边界不平整 \n");
|
||||
scanner->SetIOutBoundary(true);
|
||||
|
|
@ -92,7 +91,7 @@ FsmState *Boundary_Detection_State::on_event(ScanEvent &event)
|
|||
return scanner->test(event);
|
||||
}
|
||||
|
||||
void InitState::initial()
|
||||
void InitState::initial(void *data)
|
||||
{
|
||||
if (!(scanner->getSensor().isCoverClosed()))
|
||||
{
|
||||
|
|
@ -116,7 +115,7 @@ FsmState *InitState::on_event(ScanEvent &event)
|
|||
return scanner->test(event);
|
||||
}
|
||||
|
||||
void ErrorJamState::initial()
|
||||
void ErrorJamState::initial(void *data)
|
||||
{
|
||||
printf("FSM: 扫描仪 卡纸\n");
|
||||
scanner->put(HG_EVT_STOP_SCAN_EMERGENCY);
|
||||
|
|
@ -131,7 +130,7 @@ FsmState *ErrorJamState::on_event(ScanEvent &event)
|
|||
return scanner->test(event);
|
||||
}
|
||||
|
||||
void ErrorState::initial()
|
||||
void ErrorState::initial(void *data)
|
||||
{
|
||||
printf("FSM: 扫描仪 搓纸失败\n");
|
||||
scanner->put(HG_EVT_STOP_SCAN_EMERGENCY);
|
||||
|
|
@ -140,53 +139,14 @@ void ErrorState::initial()
|
|||
FsmState *ErrorState::on_event(ScanEvent &event)
|
||||
{
|
||||
return scanner->test(event);
|
||||
|
||||
if (event == HG_EVT_COVER_OPENED)
|
||||
{
|
||||
return FsmStateManagerEx<CoverOpenState>::GetState();
|
||||
}
|
||||
|
||||
if (scanner->getSensor().isCoverClosed() && !scanner->getSensor().isPaperStandby() && scanner->getSensor().isPaperIn())
|
||||
void ScanningState::initial(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<NoPaperState>::GetState();
|
||||
}
|
||||
else if (event == HG_EVT_PAPER_STANDBY)
|
||||
if (scanner->scanning)
|
||||
{
|
||||
printf("ErrorState on_event HG_EVT_PAPER_STANDBY\n");
|
||||
if (scanner->getSensor().isPaperStandby()) //有纸 且没卡纸
|
||||
{
|
||||
return FsmStateManagerEx<PaperReadyState>::GetState();
|
||||
return ;
|
||||
}
|
||||
else
|
||||
{
|
||||
scanner->ResetJamIn();
|
||||
return FsmStateManagerEx<NoPaperState>::GetState();
|
||||
}
|
||||
}
|
||||
else if (event == HG_EVT_CLEAR_ERR)
|
||||
{
|
||||
if (!scanner->getSensor().isCoverClosed()) //没关盖
|
||||
{
|
||||
return FsmStateManagerEx<CoverOpenState>::GetState();
|
||||
}
|
||||
else if (!scanner->GetIsJamIn())
|
||||
{
|
||||
if (scanner->getSensor().isPaperStandby()) //有纸 且没卡纸
|
||||
{
|
||||
if (!scanner->getSensor().isPaperIn())
|
||||
return FsmStateManagerEx<PaperReadyState>::GetState();
|
||||
}
|
||||
else
|
||||
{
|
||||
return FsmStateManagerEx<NoPaperState>::GetState();
|
||||
}
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
void ScanningState::initial()
|
||||
{
|
||||
if (!scanner->getSensor().isCoverClosed())
|
||||
{
|
||||
scanner->put(HG_EVT_COVER_OPENED);
|
||||
|
|
@ -202,8 +162,10 @@ void ScanningState::initial()
|
|||
scanner->put(HG_EVT_JAM_OUT);
|
||||
return ;
|
||||
}
|
||||
|
||||
printf("FSM: 扫描仪 扫描中\n");
|
||||
SetLedStatus(LedStatus::Scanning);
|
||||
scanner->seria_is_wait_ = false;
|
||||
scanner->scanning = true;
|
||||
scanner->startScan();
|
||||
}
|
||||
|
|
@ -218,7 +180,7 @@ FsmState *ScanningState::on_event(ScanEvent &event)
|
|||
return scanner->test(event);
|
||||
}
|
||||
|
||||
void Double_Paper_State::initial()
|
||||
void Double_Paper_State::initial(void *data)
|
||||
{
|
||||
printf("FSM: 扫描仪 双张 \n");
|
||||
scanner->SetIsDoublePaper(true);
|
||||
|
|
@ -230,7 +192,7 @@ FsmState *Double_Paper_State::on_event(ScanEvent &event)
|
|||
return scanner->test(event);
|
||||
}
|
||||
|
||||
void StopScanState::initial()
|
||||
void StopScanState::initial(void *data)
|
||||
{
|
||||
printf("FSM: 扫描仪 停止扫描 \n");
|
||||
scanner->stop_scan();
|
||||
|
|
@ -241,14 +203,13 @@ void StopScanState::initial()
|
|||
scanner->reset();
|
||||
scanner->scanning = false;
|
||||
}
|
||||
// scanner->put(HG_EVT_NORES);
|
||||
}
|
||||
FsmState *StopScanState::on_event(ScanEvent &event)
|
||||
{
|
||||
return scanner->test(event);
|
||||
}
|
||||
|
||||
void EmergencyStopScanState::initial()
|
||||
void EmergencyStopScanState::initial(void *data)
|
||||
{
|
||||
printf("FSM: 扫描仪 紧急停止扫描 \n");
|
||||
scanner->scanning = false;
|
||||
|
|
@ -259,7 +220,7 @@ FsmState *EmergencyStopScanState::on_event(ScanEvent &event)
|
|||
{
|
||||
return scanner->test(event);
|
||||
}
|
||||
void ScrewDetectionState::initial()
|
||||
void ScrewDetectionState::initial(void *data)
|
||||
{
|
||||
printf("FSM: 扫描仪 纸张歪斜\n");
|
||||
scanner->SetIScrewDetection(true);
|
||||
|
|
@ -271,3 +232,84 @@ FsmState *ScrewDetectionState::on_event(ScanEvent &event)
|
|||
{
|
||||
return scanner->test(event);
|
||||
}
|
||||
|
||||
void seria_stop::initial(void *data)
|
||||
{
|
||||
seria_parse_.bit.event = HG_EVT_SERIA_STOP_FEEDING;
|
||||
seria_parse_.bit.data = HG_SERIA_PROTOCOL_OK;
|
||||
if (scanner->scanning)
|
||||
{
|
||||
scanner->seria_is_wait_ = true;
|
||||
scanner->put(HG_EVT_START_SCAN);
|
||||
}
|
||||
scanner->seria_send((void *)&seria_parse_.valua,3);
|
||||
}
|
||||
FsmState *seria_stop::on_event(ScanEvent &event)
|
||||
{
|
||||
return scanner->test(event);
|
||||
}
|
||||
|
||||
void seria_start::initial(void *data)
|
||||
{
|
||||
seria_parse_.bit.event = HG_EVT_SERIA_START_FEEDING;
|
||||
seria_parse_.bit.data = HG_SERIA_PROTOCOL_OK;
|
||||
scanner->seria_cancel_wait();
|
||||
if (scanner->scanning)
|
||||
{
|
||||
scanner->put(HG_EVT_START_SCAN);
|
||||
}
|
||||
scanner->seria_send((void *)&seria_parse_.valua,3);
|
||||
}
|
||||
FsmState *seria_start::on_event(ScanEvent &event)
|
||||
{
|
||||
return scanner->test(event);
|
||||
}
|
||||
|
||||
void seria_get_status::initial(void *data)
|
||||
{
|
||||
seria_parse_.bit.event = HG_EVT_SERIA_GET_STATUS;
|
||||
seria_parse_.bit.data = HG_SERIA_PROTOCOL_OK;
|
||||
if (scanner->scanning)
|
||||
{
|
||||
seria_parse_.bit.data = HG_SERIA_IS_SCANNING;
|
||||
}
|
||||
else if (!scanner->getSensor().isCoverClosed())
|
||||
{
|
||||
seria_parse_.bit.data = HG_SERIA_COVER_OPENED;
|
||||
}
|
||||
else if(!scanner->getSensor().isPaperStandby())
|
||||
{
|
||||
seria_parse_.bit.data = HG_SERIA_NO_PAPERR;
|
||||
}
|
||||
else if(scanner->getSensor().isPaperIn())
|
||||
{
|
||||
seria_parse_.bit.data = HG_SERIA_JAM_IN;
|
||||
}
|
||||
|
||||
printf("seria_parse_.bit.data:%d\r\n",seria_parse_.bit.data);
|
||||
scanner->seria_send((void *)&seria_parse_.valua,3);
|
||||
}
|
||||
FsmState *seria_get_status::on_event(ScanEvent &event)
|
||||
{
|
||||
return scanner->test(event);
|
||||
}
|
||||
|
||||
void seria_set_speed_mode::initial(void *data)
|
||||
{
|
||||
if (!data)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
int r = *((int *)data);
|
||||
scanner->seria_set_speed(r);
|
||||
printf("串口切换速度模式：%d\r\n",r);
|
||||
seria_parse_data s;
|
||||
s.bit.data = HG_SERIA_PROTOCOL_OK;
|
||||
s.bit.event = HG_EVT_SERIA_SET_SPEED;
|
||||
scanner->seria_send((void *)&s.valua,3);
|
||||
}
|
||||
FsmState *seria_set_speed_mode::on_event(ScanEvent &event)
|
||||
{
|
||||
return scanner->test(event);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ public:
|
|||
virtual ~FsmState();
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event) = 0;
|
||||
virtual void initial() {}
|
||||
virtual void initial(void *data) {}
|
||||
|
||||
static void setScanner(Scanner* scan)
|
||||
{
|
||||
|
|
@ -30,6 +30,7 @@ public:
|
|||
protected:
|
||||
static Scanner* scanner;
|
||||
void SetLedStatus(LedStatus s);
|
||||
seria_parse_data seria_parse_;
|
||||
};
|
||||
class FsmStateManager
|
||||
{
|
||||
|
|
@ -40,7 +41,7 @@ template<typename T>
|
|||
class FsmStateManagerEx : public FsmStateManager
|
||||
{
|
||||
public:
|
||||
static FsmState* GetState()
|
||||
static FsmState* GetState(void *data)
|
||||
{
|
||||
std::string type_name = typeid(T).name();
|
||||
std::map<std::string, std::shared_ptr<FsmState>>::iterator iter = fsmStates.find(type_name);
|
||||
|
|
@ -48,7 +49,7 @@ public:
|
|||
{
|
||||
fsmStates.insert(std::pair<std::string, std::shared_ptr<FsmState>>(type_name, std::shared_ptr<FsmState>(new T)));
|
||||
}
|
||||
fsmStates[type_name]->initial();
|
||||
fsmStates[type_name]->initial(data);
|
||||
return fsmStates[type_name].get();
|
||||
}
|
||||
};
|
||||
|
|
@ -56,17 +57,17 @@ public:
|
|||
class InitState :public FsmState {
|
||||
public:
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
virtual void initial();
|
||||
virtual void initial(void *data);
|
||||
};
|
||||
class NoPaperState :public FsmState {
|
||||
public:
|
||||
virtual void initial();
|
||||
virtual void initial(void *data);
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
class PaperReadyState : public FsmState {
|
||||
public:
|
||||
PaperReadyState() {}
|
||||
virtual void initial();
|
||||
virtual void initial(void *data);
|
||||
|
||||
FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
|
|
@ -75,31 +76,31 @@ class ScanningState : public FsmState {
|
|||
public:
|
||||
ScanningState() {}
|
||||
|
||||
virtual void initial();
|
||||
virtual void initial(void *data);
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
class CoverOpenState : public FsmState {
|
||||
public:
|
||||
virtual void initial();
|
||||
virtual void initial(void *data);
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
class CoverCloseState : public FsmState {
|
||||
public:
|
||||
virtual void initial();
|
||||
virtual void initial(void *data);
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
class Double_Paper_State : public FsmState {
|
||||
public:
|
||||
virtual void initial();
|
||||
virtual void initial(void *data);
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
class Boundary_Detection_State : public FsmState {
|
||||
public:
|
||||
virtual void initial();
|
||||
virtual void initial(void *data);
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
|
|
@ -108,7 +109,7 @@ class ErrorJamState : public FsmState {
|
|||
public:
|
||||
ErrorJamState() {}
|
||||
|
||||
virtual void initial();
|
||||
virtual void initial(void *data);
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
void doPaper_pullout();
|
||||
|
|
@ -116,7 +117,7 @@ public:
|
|||
class ErrorState : public FsmState {
|
||||
public:
|
||||
ErrorState() {}
|
||||
virtual void initial();
|
||||
virtual void initial(void *data);
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
|
|
@ -125,7 +126,7 @@ class EmergencyStopScanState : public FsmState {
|
|||
public:
|
||||
EmergencyStopScanState() {}
|
||||
|
||||
virtual void initial();
|
||||
virtual void initial(void *data);
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
|
|
@ -134,7 +135,7 @@ class StopScanState : public FsmState {
|
|||
public:
|
||||
StopScanState() {}
|
||||
|
||||
virtual void initial();
|
||||
virtual void initial(void *data);
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
|
|
@ -143,7 +144,52 @@ class ScrewDetectionState : public FsmState {
|
|||
public:
|
||||
ScrewDetectionState() {}
|
||||
|
||||
virtual void initial();
|
||||
virtual void initial(void *data);
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class seria_stop : public FsmState {
|
||||
|
||||
public:
|
||||
seria_stop() {}
|
||||
|
||||
virtual void initial(void *data);
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
|
||||
class seria_start : public FsmState {
|
||||
|
||||
public:
|
||||
seria_start() {}
|
||||
|
||||
virtual void initial(void *data);
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
|
||||
class seria_get_status : public FsmState {
|
||||
|
||||
public:
|
||||
seria_get_status() {}
|
||||
|
||||
virtual void initial(void *data);
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
|
||||
class seria_set_speed_mode : public FsmState {
|
||||
|
||||
public:
|
||||
seria_set_speed_mode() {}
|
||||
|
||||
virtual void initial(void *data);
|
||||
|
||||
virtual FsmState* on_event(ScanEvent &event);
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -163,6 +163,8 @@ HCamDevice::HCamDevice()
|
|||
//camera_print("ADDR: 0x%x, Value: 0x%x\n", i, val);
|
||||
}
|
||||
|
||||
uint32_t q =0;
|
||||
HtCamGetCisType(q);
|
||||
//HtCamSetScrewDidd(1);
|
||||
}
|
||||
|
||||
|
|
@ -869,20 +871,6 @@ void HCamDevice::HtCamChangeExposureValueB(uint32_t* value)
|
|||
rgb.NShort[1] = value[2]; //B 通道
|
||||
HtCamWriteFpgaRegs(0x06,rgb.value);
|
||||
|
||||
|
||||
// pCamCtrlReg[5] = 0x00000000;
|
||||
// pCamCtrlReg[6] = 0x00000000;
|
||||
|
||||
// pCamCtrlReg[5] |= (uint32_t)(value[1]); // RED
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
||||
// pCamCtrlReg[5] |= (uint32_t)(value[1] << 16);
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
||||
// pCamCtrlReg[6] |= (uint32_t)(value[0]); // GREEN
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
||||
// pCamCtrlReg[6] |= ((uint32_t)value[2] << 16); // BLUE
|
||||
|
||||
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
||||
printf("曝光B R:%d G:%d B:%d \r\n",value[0],value[1],value[2]);
|
||||
}
|
||||
|
|
@ -902,18 +890,6 @@ void HCamDevice::HtCamChangeExposureValueF(uint32_t* value)
|
|||
rgb.NShort[1] = value[2]; //B 通道
|
||||
HtCamWriteFpgaRegs(0x0C,rgb.value);
|
||||
|
||||
// pCamCtrlReg[11] = 0x00000000;
|
||||
// pCamCtrlReg[12] = 0x00000000;
|
||||
|
||||
// pCamCtrlReg[11] |= (uint32_t)(value[1]); // RED
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
||||
// pCamCtrlReg[11] |= (uint32_t)(value[1] << 16);
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
||||
|
||||
// pCamCtrlReg[12] |= (uint32_t)(value[0]); // GREEN
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
||||
// pCamCtrlReg[12] |= ((uint32_t)value[2] << 16); // BLUE
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
||||
printf("曝光F R:%d G:%d B:%d \r\n",value[0],value[1],value[2]);
|
||||
}
|
||||
|
|
@ -930,7 +906,7 @@ void HCamDevice::HtCamWriteADCReg_ALL(bool is_gain,bool is_adc1,uint8_t addr, ui
|
|||
else
|
||||
addr += 0x0e; //偏移
|
||||
|
||||
//printf("%s 地址 :%d 值%d \r\n",is_gain?"增益":"偏移",addr,data);
|
||||
printf("%s 地址 :%d 值%d \r\n",is_gain?"增益":"偏移",addr,data);
|
||||
|
||||
uint32_t *pCamCtrlReg = virBaseAddr;
|
||||
uint32_t AdcRegFrame = 0x0000;
|
||||
|
|
@ -1072,14 +1048,17 @@ void HCamDevice::HtCamReadADCReg_ALL(uint8_t addr)
|
|||
|
||||
// printf("pAdcRegFrame->value 2222:%0x\r\n",pAdcRegFrame.value);
|
||||
// printf("pAdcRegFrame->regData2222 :%d\r\n",pAdcRegFrame.bit.regData);
|
||||
test2 t;
|
||||
t.value = HtCamReadFpgaRegs(0x01);
|
||||
printf("adc1 data:[%d] adc2 data:[%d]\r\n",t.bit.data1 , t.bit.data2);
|
||||
|
||||
CamZ_Reg_2Short rgb;
|
||||
rgb.value = HtCamReadFpgaRegs(0x01);
|
||||
CIS_ADC_NEW c ,b;
|
||||
c.value = rgb.NShort[0];
|
||||
b.value = rgb.NShort[1];
|
||||
// CamZ_Reg_2Short rgb;
|
||||
// rgb.value = HtCamReadFpgaRegs(0x01);
|
||||
// CIS_ADC_NEW c ,b;
|
||||
// c.value = rgb.NShort[0];
|
||||
// b.value = rgb.NShort[1];
|
||||
|
||||
printf("adc1 data:[%d] adc2 data:[%d]\r\n",b.bit.regData , c.bit.regData);
|
||||
//printf("adc1 data:[%d] adc2 data:[%d]\r\n",b.bit.regData , c.bit.regData);
|
||||
}
|
||||
|
||||
void HCamDevice::HtCamReadADCReg(uint8_t addr, uint8_t *data)
|
||||
|
|
@ -1425,3 +1404,9 @@ void HCamDevice:: HtCamSetScrewDidd(double reg_value)
|
|||
HtCamWriteFpgaRegs(0x16,reg.value);
|
||||
printf("reg.bit.low_reg:%d val:%f reg_value:%f\r\n",reg.bit.low_reg,val,reg_value);
|
||||
}
|
||||
|
||||
void HCamDevice::HtCamGetCisType(uint32_t& value)
|
||||
{
|
||||
value = (HtCamReadFpgaRegs(0x15)& 0xffff0000) >> 16;
|
||||
printf("%x\r\n",value);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -79,6 +79,7 @@ public:
|
|||
void HtCamSetScrewDiv(double reg_value);
|
||||
void HtCamSetScrewSamp(double reg_value);
|
||||
void HtCamSetScrewDidd(double reg_value);
|
||||
void HtCamGetCisType(uint32_t& value);
|
||||
|
||||
////////////////ADC 寄存器0x00 - 0x14///////////////////
|
||||
/////////////// 0x00 - 0xdh暂时只需要写高位，低位不用写
|
||||
|
|
|
|||
|
|
@ -17,7 +17,8 @@ Scanner::Scanner(ScannerGlue glue)
|
|||
m_jamPaper(false),m_jamIn(false),
|
||||
m_correctting(false),waitpapertime(200),
|
||||
m_scansysinfo(nullptr),auto_size_(false),
|
||||
m_iscrew(false),m_isoutBoundary(false)
|
||||
m_iscrew(false),m_isoutBoundary(false),
|
||||
seria_is_wait_(false)
|
||||
{
|
||||
frame_time_ = 3000;
|
||||
m_scaninfo = GetScanInfoFromJson();
|
||||
|
|
@ -62,7 +63,7 @@ Scanner::Scanner(ScannerGlue glue)
|
|||
}
|
||||
};
|
||||
sensor = std::make_shared<Sensor>(sysEvent);
|
||||
|
||||
seria_ = std::make_shared<seria_com>(sysEvent);
|
||||
|
||||
m_keyboard.reset(new huagao::Keyboard(btnevent));
|
||||
m_keyboard->init();
|
||||
|
|
@ -119,7 +120,7 @@ void Scanner::ConfigScanParam(HG_ScanConfiguration config)
|
|||
m_config.params.pageSize==(int)PaperSize::G400_MAXAUTO ||
|
||||
m_config.params.pageSize==(int)PaperSize::G400_MAXSIZE;
|
||||
|
||||
updateSpeedMode();
|
||||
UpdateScanInfo();
|
||||
capturer->UpdateScanParam(m_config);
|
||||
}
|
||||
void Scanner::UpdateScanInfo()
|
||||
|
|
@ -171,7 +172,8 @@ void Scanner::runMessageLoop()
|
|||
{
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(200));//避免scanpin io 开始异常
|
||||
GetSysInfo();//待fpga 重启完成
|
||||
FsmState *fsm = FsmStateManagerEx<InitState>::GetState();
|
||||
void *data = NULL;
|
||||
FsmState *fsm = FsmStateManagerEx<InitState>::GetState(data);
|
||||
while (bMsgLoop)
|
||||
{
|
||||
ScanEvent evt = sysEvent.Take();
|
||||
|
|
@ -190,6 +192,8 @@ void Scanner::processevent(ScanEvent event)
|
|||
return;
|
||||
}
|
||||
//printf("插入事件 001 ID:%d\r\n",event);
|
||||
if (event_2_hg_map_.count(event) > 0)
|
||||
|
||||
m_glue.m_deviceevent(event_2_hg_map_[event], "");
|
||||
}
|
||||
void Scanner::runScan()
|
||||
|
|
@ -226,6 +230,15 @@ void Scanner::runScan()
|
|||
isScaning = false;
|
||||
break;
|
||||
}
|
||||
if (seria_is_wait_)
|
||||
{
|
||||
seria_wait_notify();
|
||||
if (!sensor->isPaperStandby())
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
motorCuozhi.startAsyn();
|
||||
|
||||
|
|
@ -381,6 +394,7 @@ std::string Scanner::GetSysInfo()
|
|||
}
|
||||
void Scanner::emergency_stop(int id)
|
||||
{
|
||||
seria_cancel_wait();
|
||||
sensor->cancelWaitPaper();
|
||||
sensor->enableDoubleSensor(false);
|
||||
sensor->width_detect_enable(false);
|
||||
|
|
@ -397,6 +411,7 @@ void Scanner::emergency_stop(int id)
|
|||
}
|
||||
void Scanner::stop_scan()
|
||||
{
|
||||
seria_cancel_wait();
|
||||
sensor->cancelWaitPaper();
|
||||
sensor->enableDoubleSensor(false);
|
||||
sensor->width_detect_enable(false);
|
||||
|
|
@ -437,7 +452,25 @@ void Scanner::paper_pullout()
|
|||
motorZouzhi.speedRecover();
|
||||
m_isPulling = false;
|
||||
}
|
||||
|
||||
void Scanner::seria_wait_notify()
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(seria_lock_);
|
||||
wait_seria_.wait(lock);
|
||||
}
|
||||
void Scanner::seria_cancel_wait()
|
||||
{
|
||||
wait_seria_.notify_all();
|
||||
seria_is_wait_ = false;
|
||||
}
|
||||
void Scanner::seria_send(void * data,int len)
|
||||
{
|
||||
seria_->cc_seria_send(data,len);
|
||||
}
|
||||
void Scanner::seria_set_speed(int sp)
|
||||
{
|
||||
m_scaninfo.SpeedMode = sp;
|
||||
SaveScaninfo(m_scaninfo);
|
||||
}
|
||||
void Scanner::status_change_init()
|
||||
{
|
||||
status_change_map_[HG_EVT_PAPER_NOT_STANDBY] = &Scanner::status_change_standby ;
|
||||
|
|
@ -454,6 +487,16 @@ void Scanner::status_change_init()
|
|||
status_change_map_[HG_EVT_SCREW_DETECTION] = &Scanner::status_change_screw_detection;
|
||||
status_change_map_[HG_EVT_OUT_BOUNDS] = &Scanner::status_change_boundary_detection;
|
||||
|
||||
status_change_map_[HG_EVT_SERIA_STOP_FEEDING] = &Scanner::status_change_seria_stop;
|
||||
status_change_map_[HG_EVT_SERIA_START_FEEDING] = &Scanner::status_change_seria_start;
|
||||
status_change_map_[HG_EVT_SERIA_GET_STATUS] = &Scanner::status_change_seria_get_status;
|
||||
status_change_map_[HG_EVT_SERIA_SPEED_MODE_1] = &Scanner::status_change_seria_set_speed_mode;
|
||||
status_change_map_[HG_EVT_SERIA_SPEED_MODE_2] = &Scanner::status_change_seria_set_speed_mode;
|
||||
status_change_map_[HG_EVT_SERIA_SPEED_MODE_3] = &Scanner::status_change_seria_set_speed_mode;
|
||||
status_change_map_[HG_EVT_SERIA_SPEED_MODE_4] = &Scanner::status_change_seria_set_speed_mode;
|
||||
status_change_map_[HG_EVT_SERIA_SPEED_MODE_5] = &Scanner::status_change_seria_set_speed_mode;
|
||||
|
||||
|
||||
event_2_hg_map_[HG_EVT_PAPER_NOT_STANDBY] = (int)HG_ScannerStatus::NO_FEED;
|
||||
event_2_hg_map_[HG_EVT_JAM_OUT] = (int)HG_ScannerStatus::PAPER_JAM;
|
||||
event_2_hg_map_[HG_EVT_JAM_IN] = (int)HG_ScannerStatus::FEED_IN_ERROR;
|
||||
|
|
@ -463,71 +506,122 @@ void Scanner::status_change_init()
|
|||
event_2_hg_map_[HG_EVT_STOP_SCAN_EMERGENCY] = (int)HG_ScannerStatus::STOP_SCAN;
|
||||
event_2_hg_map_[HG_EVT_SCREW_DETECTION] = (int)HG_ScannerStatus::PAPER_SKEW;
|
||||
event_2_hg_map_[HG_EVT_OUT_BOUNDS] = (int)HG_ScannerStatus::BOUNDS_OUT_TEST;
|
||||
|
||||
}
|
||||
FsmState* Scanner::status_change_standby()
|
||||
FsmState* Scanner::status_change_standby(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<NoPaperState>::GetState();
|
||||
return FsmStateManagerEx<NoPaperState>::GetState(data);
|
||||
}
|
||||
FsmState *Scanner::status_change_paper_ready()
|
||||
FsmState *Scanner::status_change_paper_ready(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<PaperReadyState>::GetState();
|
||||
return FsmStateManagerEx<PaperReadyState>::GetState(data);
|
||||
}
|
||||
FsmState* Scanner::status_change_scanning()
|
||||
FsmState* Scanner::status_change_scanning(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<ScanningState>::GetState();
|
||||
return FsmStateManagerEx<ScanningState>::GetState(data);
|
||||
}
|
||||
FsmState* Scanner::status_change_paperjam()
|
||||
FsmState* Scanner::status_change_paperjam(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<ErrorJamState>::GetState();
|
||||
return FsmStateManagerEx<ErrorJamState>::GetState(data);
|
||||
}
|
||||
FsmState* Scanner::status_change_feed_in_error()
|
||||
FsmState* Scanner::status_change_feed_in_error(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<ErrorState>::GetState();
|
||||
return FsmStateManagerEx<ErrorState>::GetState(data);
|
||||
}
|
||||
FsmState* Scanner::status_change_double_paper()
|
||||
FsmState* Scanner::status_change_double_paper(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<Double_Paper_State>::GetState();
|
||||
return FsmStateManagerEx<Double_Paper_State>::GetState(data);
|
||||
}
|
||||
FsmState* Scanner::status_change_open_cover()
|
||||
FsmState* Scanner::status_change_open_cover(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<CoverOpenState>::GetState();
|
||||
return FsmStateManagerEx<CoverOpenState>::GetState(data);
|
||||
}
|
||||
FsmState* Scanner::status_change_close_cover()
|
||||
FsmState* Scanner::status_change_close_cover(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<CoverCloseState>::GetState();
|
||||
return FsmStateManagerEx<CoverCloseState>::GetState(data);
|
||||
}
|
||||
FsmState* Scanner::status_change_stop_scan()
|
||||
FsmState* Scanner::status_change_stop_scan(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<StopScanState>::GetState();
|
||||
return FsmStateManagerEx<StopScanState>::GetState(data);
|
||||
}
|
||||
FsmState* Scanner::status_change_emergency_stop_scan()
|
||||
FsmState* Scanner::status_change_emergency_stop_scan(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<EmergencyStopScanState>::GetState();
|
||||
return FsmStateManagerEx<EmergencyStopScanState>::GetState(data);
|
||||
}
|
||||
FsmState* Scanner::status_change_screw_detection()
|
||||
FsmState* Scanner::status_change_screw_detection(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<ScrewDetectionState>::GetState();
|
||||
return FsmStateManagerEx<ScrewDetectionState>::GetState(data);
|
||||
}
|
||||
FsmState* Scanner::status_change_init_status()
|
||||
FsmState* Scanner::status_change_init_status(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<InitState>::GetState();
|
||||
return FsmStateManagerEx<InitState>::GetState(data);
|
||||
}
|
||||
FsmState* Scanner::status_change_boundary_detection(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<Boundary_Detection_State>::GetState(data);
|
||||
}
|
||||
|
||||
FsmState* Scanner::status_change_boundary_detection()
|
||||
|
||||
FsmState* Scanner::status_change_seria_stop(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<Boundary_Detection_State>::GetState();
|
||||
return FsmStateManagerEx<seria_stop>::GetState(data);
|
||||
}
|
||||
FsmState* Scanner::status_change_seria_start(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<seria_start>::GetState(data);
|
||||
}
|
||||
FsmState* Scanner::status_change_seria_get_status(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<seria_get_status>::GetState(data);
|
||||
}
|
||||
FsmState* Scanner::status_change_seria_set_speed_mode(void *data)
|
||||
{
|
||||
return FsmStateManagerEx<seria_set_speed_mode>::GetState(data);
|
||||
}
|
||||
|
||||
FsmState *Scanner::test(ScanEvent e)
|
||||
{
|
||||
void * data = NULL;
|
||||
int r = 0;
|
||||
if (e == HG_EVT_SERIA_SPEED_MODE_1 || e == HG_EVT_SERIA_SPEED_MODE_2
|
||||
||e == HG_EVT_SERIA_SPEED_MODE_3
|
||||
||e == HG_EVT_SERIA_SPEED_MODE_4 ||e == HG_EVT_SERIA_SPEED_MODE_5 )
|
||||
{
|
||||
seria_protocol s = hgevt_2_seria(e);
|
||||
r = (int)s;
|
||||
}
|
||||
|
||||
|
||||
//printf("插入事件 000 ID:%d\r\n",e);
|
||||
//data = &(hgevt_2_seria(e));
|
||||
if (status_change_map_.count(e) > 0)
|
||||
{
|
||||
FsmState *fsm = (this->*status_change_map_[e])();
|
||||
FsmState *fsm = (this->*status_change_map_[e])((void*)&r);
|
||||
//printf("当前状态事件:%s\r\n",typeid(*fsm).name());
|
||||
|
||||
return fsm;
|
||||
}
|
||||
|
||||
return FsmStateManagerEx<InitState>::GetState();
|
||||
return FsmStateManagerEx<InitState>::GetState(data);
|
||||
}
|
||||
|
||||
seria_protocol Scanner::hgevt_2_seria(ScanEvent p)
|
||||
{
|
||||
switch (p)
|
||||
{
|
||||
case HG_EVT_SERIA_SPEED_MODE_1:
|
||||
return HG_SERIA_SPEED_MODE_1 ;
|
||||
|
||||
case HG_EVT_SERIA_SPEED_MODE_2:
|
||||
return HG_SERIA_SPEED_MODE_2;
|
||||
|
||||
case HG_EVT_SERIA_SPEED_MODE_3:
|
||||
return HG_SERIA_SPEED_MODE_3;
|
||||
|
||||
case HG_EVT_SERIA_SPEED_MODE_4:
|
||||
return HG_SERIA_SPEED_MODE_4;
|
||||
|
||||
case HG_EVT_SERIA_SPEED_MODE_5:
|
||||
return HG_SERIA_SPEED_MODE_5;
|
||||
}
|
||||
}
|
||||
|
|
@ -17,6 +17,7 @@
|
|||
#include "SysInforTool.h"
|
||||
#include "MotorConfig.h"
|
||||
#include "correct_ultis.h"
|
||||
#include "seria_com.h"
|
||||
|
||||
class ICapturer;
|
||||
class MemoryInfo;
|
||||
|
|
@ -27,8 +28,18 @@ class Scanner
|
|||
std::mutex cb_lock_;
|
||||
std::condition_variable wait_cb_;
|
||||
|
||||
std::mutex seria_lock_;
|
||||
std::condition_variable wait_seria_;
|
||||
public:
|
||||
void seria_cancel_wait();
|
||||
void seria_wait_notify();
|
||||
void seria_send(void * data,int len);
|
||||
void seria_set_speed(int sp);
|
||||
seria_protocol hgevt_2_seria(ScanEvent p);
|
||||
public:
|
||||
bool isScaning = false;
|
||||
volatile bool seria_is_wait_;
|
||||
|
||||
|
||||
public:
|
||||
Scanner(ScannerGlue glue);
|
||||
|
|
@ -45,6 +56,7 @@ public:
|
|||
static void have_img_callback(int val);
|
||||
std::string GetSysInfo();
|
||||
|
||||
|
||||
public:
|
||||
Sensor &getSensor() { return *sensor.get(); }
|
||||
PanelLeds &getPanelLeds() { return panelLeds; }
|
||||
|
|
@ -136,26 +148,34 @@ private:
|
|||
std::shared_ptr<ICapturer> capturer;
|
||||
std::shared_ptr<huagao::Keyboard> m_keyboard;
|
||||
std::shared_ptr<Sensor> sensor;
|
||||
|
||||
std::shared_ptr<seria_com>seria_;
|
||||
public:
|
||||
bool scanning = true;
|
||||
std::map<ScanEvent, int> event_2_hg_map_;
|
||||
std::map<int, FsmState *(Scanner::*)()> status_change_map_;
|
||||
std::map<int, FsmState *(Scanner::*)(void *data)> status_change_map_;
|
||||
void status_change_init();
|
||||
FsmState* status_change_no_paper();
|
||||
FsmState *status_change_standby();
|
||||
FsmState *status_change_paper_ready();
|
||||
FsmState *status_change_scanning();
|
||||
FsmState *status_change_paperjam();
|
||||
FsmState *status_change_feed_in_error();
|
||||
FsmState *status_change_double_paper();
|
||||
FsmState *status_change_open_cover();
|
||||
FsmState *status_change_close_cover();
|
||||
FsmState *status_change_stop_scan();
|
||||
FsmState *status_change_emergency_stop_scan();
|
||||
FsmState *status_change_screw_detection();
|
||||
FsmState *status_change_init_status();
|
||||
FsmState *status_change_boundary_detection();
|
||||
FsmState* status_change_no_paper(void *data);
|
||||
FsmState *status_change_standby(void *data);
|
||||
FsmState *status_change_paper_ready(void *data);
|
||||
FsmState *status_change_scanning(void *data);
|
||||
FsmState *status_change_paperjam(void *data);
|
||||
FsmState *status_change_feed_in_error(void *data);
|
||||
FsmState *status_change_double_paper(void *data);
|
||||
FsmState *status_change_open_cover(void *data);
|
||||
FsmState *status_change_close_cover(void *data);
|
||||
FsmState *status_change_stop_scan(void *data);
|
||||
FsmState *status_change_emergency_stop_scan(void *data);
|
||||
FsmState *status_change_screw_detection(void *data);
|
||||
FsmState *status_change_init_status(void *data);
|
||||
FsmState *status_change_boundary_detection(void *data);
|
||||
|
||||
FsmState *status_change_seria_stop(void *data);
|
||||
FsmState *status_change_seria_start(void *data);
|
||||
FsmState *status_change_seria_get_status(void *data);
|
||||
FsmState *status_change_seria_set_speed_mode(void *data);
|
||||
|
||||
|
||||
|
||||
FsmState *test(ScanEvent e);
|
||||
|
||||
};
|
||||
|
|
|
|||
|
|
@ -0,0 +1,276 @@
|
|||
#include "regsctrl.h"
|
||||
#include "unistd.h"
|
||||
#include <fcntl.h>
|
||||
#include <sys/mman.h>
|
||||
#include <thread>
|
||||
|
||||
#define CIS0003 0x516
|
||||
#define CIS0006 0x515
|
||||
Regs::Regs()
|
||||
: pregs(nullptr)
|
||||
{
|
||||
if ((fd = open("/dev/mem", O_RDWR | O_SYNC)) < 0)
|
||||
return;
|
||||
|
||||
pregs = (uint32_t *)mmap(NULL, range, PROT_READ | PROT_WRITE, MAP_SHARED, fd, base);
|
||||
}
|
||||
|
||||
Regs RegsBase::regs = Regs();
|
||||
|
||||
Regs::~Regs()
|
||||
{
|
||||
if (pregs)
|
||||
munmap(pregs, range);
|
||||
|
||||
if (fd >= 0)
|
||||
close(fd);
|
||||
}
|
||||
uint32_t *Regs::addr_base()
|
||||
{
|
||||
return pregs;
|
||||
}
|
||||
CamRegsHg::CamRegsHg()
|
||||
{
|
||||
regE = (PRegE)(regs.addr_base() + 0x0E);
|
||||
regD = (PRegD)(regs.addr_base() + 0x0D);
|
||||
regC = (PRegC)(regs.addr_base() + 0x0C);
|
||||
regB = (PRegB)(regs.addr_base() + 0x0B);
|
||||
regA = (PRegA)(regs.addr_base() + 0x0A);
|
||||
|
||||
reg16 = (PReg16)(regs.addr_base() + 0x16);
|
||||
reg15 = (PReg15)(regs.addr_base() + 0x15);
|
||||
reg14 = (PReg14)(regs.addr_base() + 0x14);
|
||||
reg13 = (PReg13)(regs.addr_base() + 0x13);
|
||||
reg12 = (PReg12)(regs.addr_base() + 0x12);
|
||||
reg11 = (PReg11)(regs.addr_base() + 0x11);
|
||||
reg10 = (PReg10)(regs.addr_base() + 0x10);
|
||||
|
||||
reg9 = (PReg9)(regs.addr_base() + 0x9);
|
||||
reg8 = (PReg8)(regs.addr_base() + 0x8);
|
||||
reg6 = (PReg6)(regs.addr_base() + 0x6);
|
||||
reg5 = (PReg5)(regs.addr_base() + 0x5);
|
||||
reg4 = (PReg4)(regs.addr_base() + 0x4);
|
||||
reg3 = (PReg3)(regs.addr_base() + 0x3);
|
||||
reg2 = (PReg2)(regs.addr_base() + 0x2);
|
||||
|
||||
//reg7_6 = (PReg1_6)(regs.addr_base() + 0x07);
|
||||
reg1_6 = (PReg1_6)(regs.addr_base() + 0x01);
|
||||
reg0_6 = (PReg0_6)(regs.addr_base() + 0x00);
|
||||
|
||||
reg17_3 = (PReg17_3)(regs.addr_base() + 0x17); ;
|
||||
reg7_3 = (PReg7_3)(regs.addr_base() + 0x07);
|
||||
reg1_3 = (PReg1_3)(regs.addr_base() + 0x01);
|
||||
reg0_3 = (PReg0_3)(regs.addr_base() + 0x00);
|
||||
|
||||
get_cis_model();
|
||||
}
|
||||
|
||||
void CamRegsHg::set_adc(bool ix, int ixreg, uint16_t val)
|
||||
{
|
||||
if (cis_type_ == CIS0006)
|
||||
{
|
||||
if (!ix)
|
||||
{
|
||||
reg0_6->rwbit1 = 0;
|
||||
reg0_6->rwbit2 = 0;
|
||||
reg0_6->addr1 = ixreg;
|
||||
reg0_6->addr2 = ixreg;
|
||||
reg0_6->data1 = val;
|
||||
reg0_6->data2 = val;
|
||||
|
||||
reg4->en_adc1_cfg = 0;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
reg4->en_adc1_cfg = 1;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
//printf("ix:%d ixreg:%d\r\n",ix,ixreg);
|
||||
return ;
|
||||
}
|
||||
|
||||
reg7_6->rwbit1 = 0;
|
||||
reg7_6->rwbit2 = 0;
|
||||
reg7_6->addr1 = ixreg;
|
||||
reg7_6->addr2 = ixreg;
|
||||
reg7_6->data1 = val;
|
||||
reg7_6->data2 = val;
|
||||
|
||||
reg4->en_adc2_cfg = 0;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
reg4->en_adc2_cfg = 1;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
//printf("ix:%d ixreg:%d\r\n",ix,ixreg);
|
||||
return ;
|
||||
}
|
||||
|
||||
if (!ix)
|
||||
{
|
||||
reg0_3->rwbit1 = 0;
|
||||
reg0_3->rwbit2 = 0;
|
||||
reg0_3->addr1 = ixreg;
|
||||
reg0_3->addr2 = ixreg;
|
||||
reg0_3->data1 = val;
|
||||
reg0_3->data2 = val;
|
||||
|
||||
reg4->en_adc1_cfg = 0;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
reg4->en_adc1_cfg = 1;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
//printf("ix:%d ixreg:%d\r\n",ix,ixreg);
|
||||
return ;
|
||||
}
|
||||
|
||||
reg7_3->rwbit1 = 0;
|
||||
reg7_3->rwbit2 = 0;
|
||||
reg7_3->addr1 = ixreg;
|
||||
reg7_3->addr2 = ixreg;
|
||||
reg7_3->data1 = val;
|
||||
reg7_3->data2 = val;
|
||||
|
||||
reg4->en_adc2_cfg = 0;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
reg4->en_adc2_cfg = 1;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
//printf("ix:%d ixreg:%d\r\n",ix,ixreg);
|
||||
}
|
||||
|
||||
|
||||
uint16_t CamRegsHg::get_adc(int ix, int ixreg)
|
||||
{
|
||||
if (cis_type_ == CIS0006)
|
||||
{
|
||||
if (!ix)
|
||||
{
|
||||
reg0_6->rwbit1 = 1;
|
||||
reg0_6->rwbit2 = 1;
|
||||
reg0_6->addr1 = ixreg;
|
||||
reg0_6->addr2 = ixreg;
|
||||
reg0_6->data1 = 0;
|
||||
reg0_6->data2 = 0;
|
||||
|
||||
reg4->en_adc1_cfg = 0;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
reg4->en_adc1_cfg = 1;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
}
|
||||
else
|
||||
{
|
||||
reg7_6->rwbit1 = 1;
|
||||
reg7_6->rwbit2 = 1;
|
||||
reg7_6->addr1 = ixreg;
|
||||
reg7_6->addr2 = ixreg;
|
||||
reg7_6->data1 = 0;
|
||||
reg7_6->data2 = 0;
|
||||
|
||||
reg4->en_adc2_cfg = 0;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
reg4->en_adc2_cfg = 1;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
}
|
||||
|
||||
//printf("ix:%d ixreg:%d\r\n",ix,ixreg);
|
||||
//printf("adc1 data:[%d] adc2 data:[%d]\r\n",Reg1_6->adc1_data , Reg1_6->adc2_data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!ix)
|
||||
{
|
||||
reg0_3->rwbit1 = 1;
|
||||
reg0_3->rwbit2 = 1;
|
||||
reg0_3->addr1 = ixreg;
|
||||
reg0_3->addr2 = ixreg;
|
||||
reg0_3->data1 = 0;
|
||||
reg0_3->data2 = 0;
|
||||
|
||||
reg4->en_adc1_cfg = 0;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
reg4->en_adc1_cfg = 1;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
reg7_3->rwbit1 = 1;
|
||||
reg7_3->rwbit2 = 1;
|
||||
reg7_3->addr1 = ixreg;
|
||||
reg7_3->addr2 = ixreg;
|
||||
reg7_3->data1 = 0;
|
||||
reg7_3->data2 = 0;
|
||||
|
||||
reg4->en_adc2_cfg = 0;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
reg4->en_adc2_cfg = 1;
|
||||
std::this_thread::sleep_for(std::chrono::microseconds(1000));
|
||||
}
|
||||
|
||||
//printf("ix:%d ixreg:%d\r\n",ix,ixreg);
|
||||
//printf("adc1 data:[%d] adc2 data:[%d]\r\n", reg1_3->adc1_data , reg17_3->adc2_data);
|
||||
}
|
||||
|
||||
|
||||
int CamRegsHg::get_cis_model()
|
||||
{
|
||||
return cis_type_ = reg15->cis_model;
|
||||
}
|
||||
|
||||
std::vector<uint16_t> CamRegsHg::get_expos()
|
||||
{
|
||||
std::vector<uint16_t> vals(6);
|
||||
vals[0] = get_expo_r(0);
|
||||
vals[1] = get_expo_g(0);
|
||||
vals[2] = get_expo_b(0);
|
||||
vals[3] = get_expo_r(1);
|
||||
vals[4] = get_expo_g(1);
|
||||
vals[5] = get_expo_b(1);
|
||||
return vals;
|
||||
}
|
||||
|
||||
void CamRegsHg::set_expos(const std::vector<uint16_t>& expos)
|
||||
{
|
||||
if (expos.size() != 6)
|
||||
return;
|
||||
|
||||
set_expo_r(0, expos[0]);
|
||||
set_expo_g(0, expos[1]);
|
||||
set_expo_b(0, expos[2]);
|
||||
set_expo_r(1, expos[3]);
|
||||
set_expo_g(1, expos[4]);
|
||||
set_expo_b(1, expos[5]);
|
||||
}
|
||||
|
||||
void CamRegsHg::set_expo_r(int ix, uint16_t val)
|
||||
{
|
||||
if (!ix)
|
||||
reg5->R1 = val;
|
||||
else
|
||||
regB->R2 = val;
|
||||
}
|
||||
|
||||
uint16_t CamRegsHg::get_expo_r(int ix)
|
||||
{
|
||||
return !ix ? reg5->R1 : regB->R2;
|
||||
}
|
||||
|
||||
void CamRegsHg::set_expo_g(int ix, uint16_t val)
|
||||
{
|
||||
if(!ix)
|
||||
reg6->G1 = val;
|
||||
else
|
||||
regC->G2 = val;
|
||||
}
|
||||
|
||||
uint16_t CamRegsHg::get_expo_g(int ix)
|
||||
{
|
||||
return !ix ? reg6->G1 : regC->G2;
|
||||
}
|
||||
|
||||
void CamRegsHg::set_expo_b(int ix, uint16_t val)
|
||||
{
|
||||
if(!ix)
|
||||
reg6->B1 = val;
|
||||
else
|
||||
regC->B2 = val;
|
||||
}
|
||||
|
||||
uint16_t CamRegsHg::get_expo_b(int ix)
|
||||
{
|
||||
return !ix ? reg6->B1 : regC->B2;
|
||||
}
|
||||
|
|
@ -0,0 +1,296 @@
|
|||
#pragma once
|
||||
#include <stdint.h>
|
||||
#include <vector>
|
||||
|
||||
//!< 0_6 and 7_6_ is cis6 , 0_3_ and 7_3_ is cis3 0x00 and 0x07 start >!
|
||||
typedef struct _Reg0_6_
|
||||
{
|
||||
uint8_t data1; // 数据区
|
||||
uint32_t reserve : 2;
|
||||
uint8_t addr1 : 5; // 寄存器地址
|
||||
uint8_t rwbit1 : 1; // 读写 1读 0写
|
||||
uint8_t data2 : 8;
|
||||
uint32_t reserve1 : 2;
|
||||
uint32_t addr2 : 5;
|
||||
uint32_t rwbit2 : 1;
|
||||
} Reg0_6, *PReg0_6;
|
||||
typedef struct _Reg7_6_
|
||||
{
|
||||
uint8_t data1;
|
||||
uint32_t reserve : 2;
|
||||
uint8_t addr1 : 5;
|
||||
uint8_t rwbit1 : 1;
|
||||
uint8_t data2: 8;
|
||||
uint32_t reserve1 : 2;
|
||||
uint32_t addr2 : 5;
|
||||
uint32_t rwbit2 : 1;
|
||||
} Reg7_6, *PReg7_6;
|
||||
|
||||
typedef struct _Reg0_3_
|
||||
{
|
||||
uint16_t data1: 9;
|
||||
uint32_t reserve : 3;
|
||||
uint8_t addr1 : 3;
|
||||
uint8_t rwbit1 : 1;
|
||||
uint8_t data2: 9;
|
||||
uint32_t reserve1 : 3;
|
||||
uint32_t addr2 : 3;
|
||||
uint32_t rwbit2 : 1;
|
||||
} Reg0_3, *PReg0_3;
|
||||
|
||||
typedef struct _Reg7_3_
|
||||
{
|
||||
uint16_t data1: 9;
|
||||
uint32_t reserve : 3;
|
||||
uint8_t addr1 : 3;
|
||||
uint8_t rwbit1 : 1;
|
||||
uint8_t data2: 9;
|
||||
uint32_t reserve1 : 3;
|
||||
uint32_t addr2 : 3;
|
||||
uint32_t rwbit2 : 1;
|
||||
} Reg7_3, *PReg7_3;
|
||||
//!< 0_6 and 7_6_ is cis6 , 0_3_ and 7_3_ is cis3 0x00 and 0x07 end >!
|
||||
|
||||
//!< _Reg1_6_ get 6cis adc data start >!
|
||||
typedef struct _Reg1_6_
|
||||
{
|
||||
uint16_t adc1_data;
|
||||
uint16_t adc2_data;
|
||||
} Reg1_6, *PReg1_6;
|
||||
//!< _Reg1_6_ get 6cis adc data end >!
|
||||
|
||||
//!< _Reg_1_3_ and _Reg17_3_ get 3cis adc1 and adc2 data start >!
|
||||
typedef struct _Reg_1_3_
|
||||
{
|
||||
uint32_t adc1_data ;
|
||||
} Reg1_3, *PReg1_3;
|
||||
|
||||
typedef struct _Reg17_3_
|
||||
{
|
||||
uint32_t adc2_data ;
|
||||
} Reg17_3, *PReg17_3;
|
||||
//!< _Reg_1_3_ and _Reg17_3_ get 3cis adc1 and adc2 data end >!
|
||||
|
||||
typedef struct _Reg2_
|
||||
{
|
||||
uint8_t button_start : 1;
|
||||
uint8_t button : 1;
|
||||
uint8_t start_stop_flag : 1;
|
||||
uint8_t trigger_flag : 1;
|
||||
} Reg2, *PReg2;
|
||||
|
||||
typedef struct _Reg3_
|
||||
{
|
||||
uint16_t sp_inter; //!< 曝光间隔 默认 49
|
||||
uint16_t sp_line; //!< 灰度内触发间隔
|
||||
} Reg3, *PReg3;
|
||||
|
||||
typedef struct _Reg4_
|
||||
{
|
||||
uint8_t reserve0 : 2;
|
||||
uint8_t mode : 1;
|
||||
uint8_t en_frameset : 1;
|
||||
uint16_t reserve1 : 9;
|
||||
uint8_t en_adc1_cfg : 1;
|
||||
uint8_t en_adc2_cfg : 1;
|
||||
uint8_t clr_exp : 1;
|
||||
uint8_t soft_rst_n : 1;
|
||||
uint8_t en_pattern : 1;
|
||||
uint16_t en_line : 1;
|
||||
} Reg4, *PReg4;
|
||||
|
||||
typedef struct _Reg5_
|
||||
{
|
||||
uint16_t reserve0;
|
||||
uint16_t R1;
|
||||
} Reg5, *PReg5;
|
||||
|
||||
typedef struct _Reg6_
|
||||
{
|
||||
uint16_t G1;
|
||||
uint16_t B1;
|
||||
} Reg6, *PReg6;
|
||||
|
||||
typedef struct _Reg8_
|
||||
{
|
||||
uint8_t i_ctr1;
|
||||
uint16_t i_devder;
|
||||
uint8_t reserve;
|
||||
} Reg8, *PReg8;
|
||||
|
||||
typedef struct _Reg9_
|
||||
{
|
||||
uint8_t i_period;
|
||||
uint16_t i_dc;
|
||||
} Reg9, *PReg9;
|
||||
|
||||
typedef struct _RegA_
|
||||
{
|
||||
uint8_t start : 1;
|
||||
uint8_t stop : 1;
|
||||
uint8_t reserve : 5;
|
||||
uint8_t finished : 1;
|
||||
uint8_t psen : 1;
|
||||
uint8_t psincdec : 1;
|
||||
uint8_t clr_psedon : 1;
|
||||
uint8_t dpi : 1; //!< 1 : 300dpi , 0 : 600dpi
|
||||
uint32_t reserve1 : 20;
|
||||
} RegA, *PRegA;
|
||||
|
||||
typedef struct _RegB_
|
||||
{
|
||||
uint16_t reserve;
|
||||
uint16_t R2;
|
||||
} RegB, *PRegB;
|
||||
|
||||
typedef struct _RegC_
|
||||
{
|
||||
uint16_t G2;
|
||||
uint16_t B2;
|
||||
} RegC, *PRegC;
|
||||
|
||||
typedef struct _RegD_
|
||||
{
|
||||
uint16_t line_cnt;
|
||||
uint16_t mo;
|
||||
} RegD, *PRegD;
|
||||
|
||||
typedef struct _RegE_
|
||||
{
|
||||
uint16_t send_line_cnt;
|
||||
} RegE, *PRegE;
|
||||
|
||||
typedef struct _Reg10_
|
||||
{
|
||||
uint8_t vsnp1;
|
||||
uint8_t vsnp2;
|
||||
uint16_t reserve;
|
||||
} Reg10, *PReg10;
|
||||
|
||||
typedef struct _Reg11_
|
||||
{
|
||||
uint8_t dev_reg : 6;
|
||||
uint16_t samp_reg : 10;
|
||||
uint16_t low_reg : 10;
|
||||
uint16_t reserve : 6;
|
||||
} Reg11, *PReg11;
|
||||
|
||||
typedef struct _Reg12_
|
||||
{
|
||||
uint32_t autogig_dly_time;
|
||||
} Reg12, *PReg12;
|
||||
|
||||
typedef struct _Reg13_
|
||||
{
|
||||
uint16_t sp_time2; //!< 彩色模式下的内触发间隔
|
||||
uint16_t reserve;
|
||||
} Reg13, *PReg13;
|
||||
|
||||
typedef struct _Reg14_
|
||||
{
|
||||
uint16_t frame_cnt;
|
||||
uint16_t reserve;
|
||||
} Reg14, *PReg14;
|
||||
|
||||
typedef struct _Reg15_
|
||||
{
|
||||
uint16_t frame_tx;
|
||||
uint16_t cis_model;
|
||||
} Reg15, *PReg15;
|
||||
|
||||
typedef struct _Reg16_
|
||||
{
|
||||
uint8_t dev_reg : 6;
|
||||
uint16_t samp_reg : 10;
|
||||
uint16_t diff_reg : 10;
|
||||
uint16_t reserve : 6;
|
||||
} Reg16, *PReg16;
|
||||
|
||||
|
||||
class Regs
|
||||
{
|
||||
private:
|
||||
/* data */
|
||||
public:
|
||||
Regs(/* args */);
|
||||
~Regs();
|
||||
int read(int ix);
|
||||
void write(int ix , int val);
|
||||
uint32_t* addr_base();
|
||||
private:
|
||||
const int base = 0x40010000;
|
||||
const int range = 0x100;
|
||||
|
||||
int fd;
|
||||
uint32_t* pregs;
|
||||
};
|
||||
|
||||
class RegsBase
|
||||
{
|
||||
protected:
|
||||
static Regs regs;
|
||||
};
|
||||
|
||||
class CamRegsHg : public RegsBase
|
||||
{
|
||||
public:
|
||||
CamRegsHg();
|
||||
|
||||
//!< 0x00 and 0x07 start
|
||||
void set_adc(bool ix, int ixreg, uint16_t val);
|
||||
//!< 0x00 and 0x07 end
|
||||
|
||||
//!< 0x01 start
|
||||
uint16_t get_adc(int ix, int ixreg);
|
||||
//!< 0x01 end
|
||||
|
||||
std::vector<uint16_t> get_expos();
|
||||
void set_expos(const std::vector<uint16_t>& expos);
|
||||
|
||||
void set_expo_r(int ix, uint16_t val);
|
||||
uint16_t get_expo_r(int ix);
|
||||
void set_expo_g(int ix, uint16_t val);
|
||||
uint16_t get_expo_g(int ix);
|
||||
void set_expo_b(int ix, uint16_t val);
|
||||
uint16_t get_expo_b(int ix);
|
||||
|
||||
//!< 0x15 start
|
||||
int get_cis_model();
|
||||
//!< 0x15 start
|
||||
|
||||
int cis_type_;
|
||||
|
||||
private:
|
||||
const int dpi300 = 5184;
|
||||
|
||||
PRegE regE;
|
||||
PRegD regD;
|
||||
PRegC regC;
|
||||
PRegB regB;
|
||||
PRegA regA;
|
||||
PReg16 reg16;
|
||||
PReg15 reg15;
|
||||
PReg14 reg14;
|
||||
PReg13 reg13;
|
||||
PReg12 reg12;
|
||||
PReg11 reg11;
|
||||
PReg10 reg10;
|
||||
PReg9 reg9;
|
||||
PReg8 reg8;
|
||||
PReg6 reg6;
|
||||
PReg5 reg5;
|
||||
PReg4 reg4;
|
||||
PReg3 reg3;
|
||||
PReg2 reg2;
|
||||
|
||||
//!< adc read and write _3 is 3cis _6 is 6cis start >!
|
||||
PReg17_3 reg17_3;
|
||||
PReg7_3 reg7_3;
|
||||
PReg1_3 reg1_3;
|
||||
PReg0_3 reg0_3;
|
||||
|
||||
PReg7_6 reg7_6;
|
||||
PReg1_6 reg1_6;
|
||||
PReg0_6 reg0_6;
|
||||
//!< adc read and write _3 is 3cis _6 is 6cis end >!
|
||||
};
|
||||
|
|
@ -312,7 +312,6 @@ enum scanner_err
|
|||
SCANNER_ERR_UPDATE_UNZIP_FAIL, //设备更新：解压失败
|
||||
};
|
||||
|
||||
|
||||
enum ScanEvent {
|
||||
HG_EVT_NORES = 0x00,
|
||||
HG_EVT_SCAN_FINISHED ,
|
||||
|
|
@ -343,10 +342,51 @@ enum ScanEvent {
|
|||
HG_EVT_PAPER_NOT_STANDBY,
|
||||
HG_EVT_PAPER_STANDBY,
|
||||
HG_EVT_SCREW_DETECTION,
|
||||
HG_EVT_SCREW_NOT_DETECTION
|
||||
HG_EVT_SCREW_NOT_DETECTION,
|
||||
|
||||
|
||||
HG_EVT_SERIA_START_FEEDING = 0x1000,
|
||||
HG_EVT_SERIA_STOP_FEEDING,
|
||||
HG_EVT_SERIA_GET_STATUS,
|
||||
HG_EVT_SERIA_SET_SPEED,
|
||||
|
||||
HG_EVT_SERIA_SPEED_MODE_1,
|
||||
HG_EVT_SERIA_SPEED_MODE_2,
|
||||
HG_EVT_SERIA_SPEED_MODE_3,
|
||||
HG_EVT_SERIA_SPEED_MODE_4,
|
||||
HG_EVT_SERIA_SPEED_MODE_5,
|
||||
HG_EVT_SERIA_PROTOCOL_ERROR = 0x1100,
|
||||
HG_EVT_SERIA_RESERVED = 0x1100,
|
||||
};
|
||||
|
||||
|
||||
union seria_parse_data
|
||||
{
|
||||
uint32_t valua;
|
||||
struct
|
||||
{
|
||||
uint32_t data:5;
|
||||
uint32_t event:13;
|
||||
uint32_t reserved:14;
|
||||
}bit;
|
||||
|
||||
};
|
||||
|
||||
enum seria_protocol
|
||||
{
|
||||
HG_SERIA_PROTOCOL_OK = 0X00,
|
||||
HG_SERIA_SPEED_MODE_1,
|
||||
HG_SERIA_SPEED_MODE_2,
|
||||
HG_SERIA_SPEED_MODE_3,
|
||||
HG_SERIA_SPEED_MODE_4,
|
||||
HG_SERIA_SPEED_MODE_5,
|
||||
HG_SERIA_COVER_OPENED,
|
||||
HG_SERIA_NO_PAPERR,
|
||||
HG_SERIA_JAM_IN ,
|
||||
HG_SERIA_IS_SCANNING,
|
||||
HG_SERIA_PROTOCOL_ERROR = 0x1F,
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int Command;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,111 @@
|
|||
#include <seria_com.h>
|
||||
#define SERIAL_PORT "/dev/ttyPS1"
|
||||
seria_com::seria_com(BlockingQueue<ScanEvent>& sysEvents):events(sysEvents)
|
||||
{
|
||||
serialib_.reset(new serialib);
|
||||
if (!serialib_.get())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
int ret = serialib_->openDevice(SERIAL_PORT,19200);
|
||||
if(ret != 1) return ;
|
||||
|
||||
printf("Ok To Open Port: %s \r\n", SERIAL_PORT);
|
||||
thread_seria = std::thread(&seria_com::thread_seria_com,this);
|
||||
}
|
||||
|
||||
seria_com::~seria_com()
|
||||
{
|
||||
}
|
||||
void seria_com::thread_seria_com()
|
||||
{
|
||||
std::vector<uint8_t> buf;
|
||||
while (serialib_.get())
|
||||
{
|
||||
if (serialib_->waitAvailable(100) >= 0)
|
||||
{
|
||||
buf.resize(serialib_->available());
|
||||
serialib_->readBytes((void *)buf.data(), buf.size(), 0, 0);
|
||||
parse_com_data(buf.data(),buf.size());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void seria_com::parse_com_data(uint8_t *buf,size_t len)
|
||||
{
|
||||
std::vector<uint8_t> vec;
|
||||
vec.resize(len);
|
||||
vec.push_back(HG_SERIA_PROTOCOL_ERROR);
|
||||
if (len != 3 )
|
||||
{
|
||||
printf("协议数量错误!!!\r\n");
|
||||
cc_seria_send(vec.data(),vec.size());
|
||||
return ;
|
||||
}
|
||||
|
||||
seria_parse_data parse;
|
||||
|
||||
int c = buf[0] << 11 ;
|
||||
int d = c | buf[1] ;
|
||||
|
||||
printf("d :%d %x\r\n",d, d);
|
||||
parse.valua = d << 5 | buf[2];
|
||||
|
||||
|
||||
ScanEvent e;
|
||||
printf("parse.bit.event:%d data :%d\r\n",parse.bit.event,parse.bit.data);
|
||||
switch (parse.bit.event)
|
||||
{
|
||||
case HG_EVT_SERIA_SET_SPEED:
|
||||
|
||||
e = seria_to_hgevt((seria_protocol)parse.bit.data);
|
||||
if (e == HG_EVT_SERIA_PROTOCOL_ERROR)
|
||||
{
|
||||
cc_seria_send(vec.data(),vec.size());
|
||||
break;
|
||||
}
|
||||
events.Put(e);
|
||||
break;
|
||||
case HG_EVT_SERIA_START_FEEDING:
|
||||
case HG_EVT_SERIA_STOP_FEEDING:
|
||||
case HG_EVT_SERIA_GET_STATUS:
|
||||
if (parse.bit.data != HG_SERIA_PROTOCOL_OK)
|
||||
{
|
||||
cc_seria_send(vec.data(),vec.size());
|
||||
break;
|
||||
}
|
||||
events.Put((ScanEvent)parse.bit.event);
|
||||
break;
|
||||
|
||||
default:
|
||||
cc_seria_send(vec.data(),vec.size());
|
||||
break;
|
||||
}
|
||||
|
||||
printf("协议 READ :%d %x\r\n",parse.valua,parse.valua);
|
||||
|
||||
}
|
||||
|
||||
void seria_com::cc_seria_send(void * data,int len)
|
||||
{
|
||||
serialib_->writeBytes(data, len);
|
||||
}
|
||||
ScanEvent seria_com::seria_to_hgevt(seria_protocol p)
|
||||
{
|
||||
switch (p)
|
||||
{
|
||||
case HG_SERIA_SPEED_MODE_1:
|
||||
return HG_EVT_SERIA_SPEED_MODE_1;
|
||||
case HG_SERIA_SPEED_MODE_2:
|
||||
return HG_EVT_SERIA_SPEED_MODE_2;
|
||||
case HG_SERIA_SPEED_MODE_3:
|
||||
return HG_EVT_SERIA_SPEED_MODE_3;
|
||||
case HG_SERIA_SPEED_MODE_4:
|
||||
return HG_EVT_SERIA_SPEED_MODE_4;
|
||||
case HG_SERIA_SPEED_MODE_5:
|
||||
return HG_EVT_SERIA_SPEED_MODE_5;
|
||||
default:
|
||||
return HG_EVT_SERIA_PROTOCOL_ERROR;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
|
||||
|
||||
#include <string.h>
|
||||
#include <string>
|
||||
#include <thread>
|
||||
#include "BlockingQueue.h"
|
||||
#include "scanservices_utils.h"
|
||||
#include <serialib.h>
|
||||
#include <vector>
|
||||
|
||||
class seria_com
|
||||
{
|
||||
private:
|
||||
BlockingQueue<ScanEvent>& events;
|
||||
std::thread thread_seria;
|
||||
void thread_seria_com();
|
||||
volatile bool bseria = true;
|
||||
std::shared_ptr<serialib> serialib_;
|
||||
void parse_com_data(uint8_t *buf,size_t len);
|
||||
ScanEvent seria_to_hgevt(seria_protocol p);
|
||||
public:
|
||||
seria_com(BlockingQueue<ScanEvent>& sysEvents);
|
||||
~seria_com();
|
||||
void cc_seria_send(void * data,int len);
|
||||
};
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,270 @@
|
|||
/*!
|
||||
\file serialib.h
|
||||
\brief Header file of the class serialib. This class is used for communication over a serial device.
|
||||
\author Philippe Lucidarme (University of Angers)
|
||||
\version 2.0
|
||||
\date december the 27th of 2019
|
||||
This Serial library is used to communicate through serial port.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
||||
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM,
|
||||
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
This is a licence-free software, it can be used by anyone who try to build a better world.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef SERIALIB_H
|
||||
#define SERIALIB_H
|
||||
|
||||
#if defined(__CYGWIN__)
|
||||
// This is Cygwin special case
|
||||
#include <sys/time.h>
|
||||
#endif
|
||||
|
||||
// Include for windows
|
||||
#if defined (_WIN32) || defined (_WIN64)
|
||||
#if defined(__GNUC__)
|
||||
// This is MinGW special case
|
||||
#include <sys/time.h>
|
||||
#else
|
||||
// sys/time.h does not exist on "actual" Windows
|
||||
#define NO_POSIX_TIME
|
||||
#endif
|
||||
// Accessing to the serial port under Windows
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
// Include for Linux
|
||||
#if defined (__linux__) || defined(__APPLE__)
|
||||
#include <stdlib.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/shm.h>
|
||||
#include <termios.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <sys/time.h>
|
||||
// File control definitions
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/poll.h>
|
||||
#endif
|
||||
|
||||
/*! To avoid unused parameters */
|
||||
#define UNUSED(x) (void)(x)
|
||||
|
||||
/**
|
||||
* number of serial data bits
|
||||
*/
|
||||
enum SerialDataBits {
|
||||
SERIAL_DATABITS_5, /**< 5 databits */
|
||||
SERIAL_DATABITS_6, /**< 6 databits */
|
||||
SERIAL_DATABITS_7, /**< 7 databits */
|
||||
SERIAL_DATABITS_8, /**< 8 databits */
|
||||
SERIAL_DATABITS_16, /**< 16 databits */
|
||||
};
|
||||
|
||||
/**
|
||||
* number of serial stop bits
|
||||
*/
|
||||
enum SerialStopBits {
|
||||
SERIAL_STOPBITS_1, /**< 1 stop bit */
|
||||
SERIAL_STOPBITS_1_5, /**< 1.5 stop bits */
|
||||
SERIAL_STOPBITS_2, /**< 2 stop bits */
|
||||
};
|
||||
|
||||
/**
|
||||
* type of serial parity bits
|
||||
*/
|
||||
enum SerialParity {
|
||||
SERIAL_PARITY_NONE, /**< no parity bit */
|
||||
SERIAL_PARITY_EVEN, /**< even parity bit */
|
||||
SERIAL_PARITY_ODD, /**< odd parity bit */
|
||||
SERIAL_PARITY_MARK, /**< mark parity */
|
||||
SERIAL_PARITY_SPACE /**< space bit */
|
||||
};
|
||||
|
||||
/*! \class serialib
|
||||
\brief This class is used for communication over a serial device.
|
||||
*/
|
||||
class serialib
|
||||
{
|
||||
public:
|
||||
|
||||
//_____________________________________
|
||||
// ::: Constructors and destructors :::
|
||||
|
||||
|
||||
|
||||
// Constructor of the class
|
||||
serialib ();
|
||||
|
||||
// Destructor
|
||||
~serialib ();
|
||||
|
||||
|
||||
|
||||
//_________________________________________
|
||||
// ::: Configuration and initialization :::
|
||||
|
||||
|
||||
// Open a device
|
||||
char openDevice(const char *Device, const unsigned int Bauds,
|
||||
SerialDataBits Databits = SERIAL_DATABITS_8,
|
||||
SerialParity Parity = SERIAL_PARITY_NONE,
|
||||
SerialStopBits Stopbits = SERIAL_STOPBITS_1);
|
||||
|
||||
// Check device opening state
|
||||
bool isDeviceOpen();
|
||||
|
||||
// Close the current device
|
||||
void closeDevice();
|
||||
|
||||
|
||||
|
||||
|
||||
//___________________________________________
|
||||
// ::: Read/Write operation on characters :::
|
||||
|
||||
|
||||
// Write a char
|
||||
int writeChar (char);
|
||||
|
||||
// Read a char (with timeout)
|
||||
int readChar (char *pByte,const unsigned int timeOut_ms=0);
|
||||
|
||||
|
||||
|
||||
|
||||
//________________________________________
|
||||
// ::: Read/Write operation on strings :::
|
||||
|
||||
|
||||
// Write a string
|
||||
int writeString (const char *String);
|
||||
|
||||
// Read a string (with timeout)
|
||||
int readString ( char *receivedString,
|
||||
char finalChar,
|
||||
unsigned int maxNbBytes,
|
||||
const unsigned int timeOut_ms=0);
|
||||
|
||||
|
||||
|
||||
// _____________________________________
|
||||
// ::: Read/Write operation on bytes :::
|
||||
|
||||
|
||||
// Write an array of bytes
|
||||
int writeBytes (const void *Buffer, unsigned int NbBytes);
|
||||
|
||||
// Read an array of byte (with timeout)
|
||||
int readBytes (void *buffer,unsigned int maxNbBytes,const unsigned int timeOut_ms=0, unsigned int sleepDuration_us=100);
|
||||
|
||||
|
||||
|
||||
|
||||
// _________________________
|
||||
// ::: Special operation :::
|
||||
|
||||
|
||||
// Empty the received buffer
|
||||
char flushReceiver();
|
||||
|
||||
// Return the number of bytes in the received buffer
|
||||
int available();
|
||||
|
||||
|
||||
int waitAvailable(int timeOut);
|
||||
|
||||
// _________________________
|
||||
// ::: Access to IO bits :::
|
||||
|
||||
|
||||
// Set CTR status (Data Terminal Ready, pin 4)
|
||||
bool DTR(bool status);
|
||||
bool setDTR();
|
||||
bool clearDTR();
|
||||
|
||||
// Set RTS status (Request To Send, pin 7)
|
||||
bool RTS(bool status);
|
||||
bool setRTS();
|
||||
bool clearRTS();
|
||||
|
||||
// Get RI status (Ring Indicator, pin 9)
|
||||
bool isRI();
|
||||
|
||||
// Get DCD status (Data Carrier Detect, pin 1)
|
||||
bool isDCD();
|
||||
|
||||
// Get CTS status (Clear To Send, pin 8)
|
||||
bool isCTS();
|
||||
|
||||
// Get DSR status (Data Set Ready, pin 9)
|
||||
bool isDSR();
|
||||
|
||||
// Get RTS status (Request To Send, pin 7)
|
||||
bool isRTS();
|
||||
|
||||
// Get CTR status (Data Terminal Ready, pin 4)
|
||||
bool isDTR();
|
||||
|
||||
|
||||
private:
|
||||
// Read a string (no timeout)
|
||||
int readStringNoTimeOut (char *String,char FinalChar,unsigned int MaxNbBytes);
|
||||
|
||||
// Current DTR and RTS state (can't be read on WIndows)
|
||||
bool currentStateRTS;
|
||||
bool currentStateDTR;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#if defined (_WIN32) || defined( _WIN64)
|
||||
// Handle on serial device
|
||||
HANDLE hSerial;
|
||||
// For setting serial port timeouts
|
||||
COMMTIMEOUTS timeouts;
|
||||
#endif
|
||||
#if defined (__linux__) || defined(__APPLE__)
|
||||
int fd;
|
||||
#endif
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
/*! \class timeOut
|
||||
\brief This class can manage a timer which is used as a timeout.
|
||||
*/
|
||||
// Class timeOut
|
||||
class timeOut
|
||||
{
|
||||
public:
|
||||
|
||||
// Constructor
|
||||
timeOut();
|
||||
|
||||
// Init the timer
|
||||
void initTimer();
|
||||
|
||||
// Return the elapsed time since initialization
|
||||
unsigned long int elapsedTime_ms();
|
||||
|
||||
private:
|
||||
#if defined (NO_POSIX_TIME)
|
||||
// Used to store the previous time (for computing timeout)
|
||||
LONGLONG counterFrequency;
|
||||
LONGLONG previousTime;
|
||||
#else
|
||||
// Used to store the previous time (for computing timeout)
|
||||
struct timeval previousTime;
|
||||
#endif
|
||||
};
|
||||
|
||||
#endif // serialib_H
|
||||
Loading…
Reference in New Issue