404 lines
14 KiB
C++
404 lines
14 KiB
C++
|
#include "MenuComponent.h"
|
||
|
#include "DisplayCenter.h"
|
||
|
#include "keymonitor.h"
|
||
|
#include "regsaccess.h"
|
||
|
#include "StateControl.h"
|
||
|
#include "wakeup.hpp"
|
||
|
#include "MotorboardParam.h"
|
||
|
|
||
|
StateControl::StateControl(std::shared_ptr<IRegsAccess> m_regsAccess,std::shared_ptr<WakeUp> wake):m_regs(m_regsAccess),m_wake(wake),
|
||
|
is_runing(false),is_cover_open(false),is_autopaper(false),en_autopaper_key(false){
|
||
|
m_menu.reset(new MenuComponent());
|
||
|
m_menu->initmenu();
|
||
|
m_discenter.reset(new DisplayCenter());
|
||
|
uint reg6value = 0;
|
||
|
m_regs->read(0x6,reg6value);
|
||
|
auto reg = *(reg6*)®6value;
|
||
|
MotorboardParam::MBParam mb_param = MotorboardParam().GetParam();
|
||
|
reg.param.work_mode = 0;
|
||
|
reg.param.lift_init_set = mb_param.trayposition;
|
||
|
switch (mb_param.feedmode)
|
||
|
{
|
||
|
case 0:
|
||
|
reg.param.func_feed_low =1;
|
||
|
reg.param.func_feed_high = reg.param.func_feed_mid = 0;
|
||
|
break;
|
||
|
case 1:
|
||
|
reg.param.func_feed_mid =1;
|
||
|
reg.param.func_feed_high = reg.param.func_feed_low = 0;
|
||
|
break;
|
||
|
case 2:
|
||
|
reg.param.func_feed_high =1;
|
||
|
reg.param.func_feed_mid = reg.param.func_feed_low = 0;
|
||
|
break;
|
||
|
default:
|
||
|
reg.param.func_feed_mid =1;
|
||
|
reg.param.func_feed_high = reg.param.func_feed_low = 0;
|
||
|
break;
|
||
|
}
|
||
|
m_regs->write(0x6,reg.value);
|
||
|
auto keycall = [&](int keyvalye)
|
||
|
{
|
||
|
if(wake.get())
|
||
|
wake->resettime();
|
||
|
std::cout << "keycallback keyvalue= " << keyvalye << std::endl;
|
||
|
uint value = 0;
|
||
|
auto key = (KeyMonitor::HGKey)(keyvalye);
|
||
|
if((is_autopaper && (!en_autopaper_key)) || (is_autopaper && en_autopaper_key && (key!=KeyMonitor::HGKey::Key_Cancle)))
|
||
|
return ;
|
||
|
if((is_runing && key!=KeyMonitor::HGKey::Key_Cancle)||is_cover_open)
|
||
|
return ;
|
||
|
value = 0;
|
||
|
switch (key)
|
||
|
{
|
||
|
case KeyMonitor::HGKey::Key_Enter:
|
||
|
{
|
||
|
m_regs->read(0x6,value);
|
||
|
auto reg = *(reg6*)&value;
|
||
|
printf("\n reg.param.work_mode = %d ",reg.param.work_mode);
|
||
|
if(reg.param.work_mode !=1)
|
||
|
break;
|
||
|
m_regs->read(0x02,value);
|
||
|
if(!(value&0x10000))
|
||
|
{
|
||
|
PutMsg(DisType::Dis_Err_NoPaper,0,ClearScreen::All);
|
||
|
break;
|
||
|
}
|
||
|
setrunstate(true);
|
||
|
reg.param.func_encount = 1;
|
||
|
m_regs->write(0x6,reg.value);
|
||
|
reg.param.func_encount = 0;
|
||
|
m_regs->write(0x6,reg.value);
|
||
|
if(m_wake.get())
|
||
|
m_wake->setsleepfalg(true);
|
||
|
printf("\n m_menu->getcurindex() %d",m_menu->getcurindex());
|
||
|
m_discenter->PutMsg(DisType::Dis_Set_Count,0,ClearScreen::All);
|
||
|
PutMsg(DisType::Dis_Scan_Page,getpapercount(),ClearScreen::BOT);
|
||
|
break;
|
||
|
}
|
||
|
case KeyMonitor::HGKey::Key_Cancle:
|
||
|
{
|
||
|
m_regs->read(0x06,value);
|
||
|
reg6 func = *(reg6*)&value;
|
||
|
m_menu->setcurindex(0);
|
||
|
m_discenter->PutMsg(func.param.work_mode == 0? (is_runing?DisType::Dis_Scan : DisType::Dis_Idel):(func.param.work_mode == 1?DisType::Dis_Set_Count:DisType::Dis_HandMode),0,ClearScreen::All);
|
||
|
if(m_discenter->getcurdistype() == DisType::Dis_Scan || m_discenter->getcurdistype() == DisType::Dis_Set_Count)
|
||
|
{
|
||
|
PutMsg(DisType::Dis_Scan_Page,getpapercount(),ClearScreen::BOT);
|
||
|
}
|
||
|
autopaperstop?autopaperstop():void();
|
||
|
if(!is_runing)
|
||
|
break;
|
||
|
func.param.key_stop_enable = true;
|
||
|
m_regs->write(0x06,func.value);
|
||
|
func.param.key_stop_enable = false;
|
||
|
m_regs->write(0x06,func.value);
|
||
|
if(m_wake.get())
|
||
|
m_wake->setsleepfalg(false);
|
||
|
//is_runing = false;
|
||
|
// if(int(m_discenter->getcurdistype()) > 4 && int(m_discenter->getcurdistype())<14)
|
||
|
// m_discenter->PutMsg(DisType::Dis_Idel,0,ClearScreen::All);
|
||
|
break;
|
||
|
}
|
||
|
case KeyMonitor::HGKey::Key_Count:
|
||
|
{
|
||
|
if(m_discenter->getcurdistype() != DisType::Dis_Idel)
|
||
|
{
|
||
|
m_menu->setcurindex(0);
|
||
|
m_discenter->PutMsg(DisType::Dis_Idel, 0,ClearScreen::All);
|
||
|
}
|
||
|
m_regs->read(0x6,value);
|
||
|
auto reg = *(reg6*)&value;
|
||
|
printf("\n reg.param.work_mode = %d ",reg.param.work_mode);
|
||
|
if(reg.param.work_mode!= 0 && reg.param.work_mode !=1)
|
||
|
break;
|
||
|
if(reg.param.work_mode == 1){
|
||
|
reg.param.work_mode = 0;
|
||
|
m_keymonitor->setled(KeyMonitor::HGLed::Led_Count_close);
|
||
|
}
|
||
|
else{
|
||
|
reg.param.work_mode = 1;
|
||
|
clearcount();
|
||
|
getpapercount();
|
||
|
PutMsg(DisType::Dis_Scan_Page,getpapercount(),ClearScreen::BOT);
|
||
|
m_keymonitor->setled(KeyMonitor::HGLed::Led_Count_open);
|
||
|
}
|
||
|
m_regs->write(0x6,reg.value);
|
||
|
m_discenter->PutMsg(reg.param.work_mode == 1?DisType::Dis_Set_Count:DisType::Dis_Idel,0, reg.param.work_mode == 1?ClearScreen::TOP : ClearScreen::All);
|
||
|
break;
|
||
|
}
|
||
|
// case KeyMonitor::HGKey::Key_Handle:
|
||
|
// {
|
||
|
// m_regs->read(0x6,value);
|
||
|
// auto reg = *(reg6*)&value;
|
||
|
// printf("\n reg.param.work_mode = %d ",reg.param.work_mode);
|
||
|
// if(reg.param.work_mode!= 0 && reg.param.work_mode !=5)
|
||
|
// break;
|
||
|
// if(reg.param.work_mode == 5){
|
||
|
// reg.param.work_mode = 0;
|
||
|
// m_keymonitor->setled(KeyMonitor::HGLed::Led_Handle_close);
|
||
|
// }
|
||
|
// else{
|
||
|
// reg.param.work_mode = 5;
|
||
|
// m_keymonitor->setled(KeyMonitor::HGLed::Led_Handle_open);
|
||
|
// }
|
||
|
// m_regs->write(0x6,reg.value);
|
||
|
// m_discenter->PutMsg(reg.param.work_mode == 5?DisType::Dis_HandMode:DisType::Dis_Idel,0,ClearScreen::All);
|
||
|
// break;
|
||
|
// }
|
||
|
case KeyMonitor::HGKey::Key_DoubleFeed:
|
||
|
{
|
||
|
m_regs->read(0x6,value);
|
||
|
auto reg = *(reg6*)&value;
|
||
|
printf("\n reg.param.key_endouble_feed =%d ",reg.param.key_endouble_feed);
|
||
|
if(reg.param.key_endouble_feed){
|
||
|
reg.param.key_endouble_feed = 0;
|
||
|
m_keymonitor->setled(KeyMonitor::HGLed::Led_DoubleFeed_close);
|
||
|
}
|
||
|
else{
|
||
|
reg.param.key_endouble_feed = 1;
|
||
|
m_keymonitor->setled(KeyMonitor::HGLed::Led_DoubleFeed_open);
|
||
|
}
|
||
|
m_regs->write(0x6,reg.value);
|
||
|
break;
|
||
|
}
|
||
|
case KeyMonitor::HGKey::Key_Left:
|
||
|
case KeyMonitor::HGKey::Key_Menu:
|
||
|
case KeyMonitor::HGKey::Key_Right:
|
||
|
{
|
||
|
m_regs->read(0x6,value);
|
||
|
auto reg = *(reg6*)&value;
|
||
|
if(reg.param.work_mode != 0)
|
||
|
break;
|
||
|
if(keyvalye == (int)KeyMonitor::HGKey::Key_Menu)
|
||
|
menu_func(m_menu->getcurtype());
|
||
|
printf("\n m_menu->getcurindex() %d",m_menu->getcurindex());
|
||
|
printf("\n mb 6 value%d",reg.value);
|
||
|
if(keyvalye == (int)KeyMonitor::HGKey::Key_Menu && m_menu->getcurindex() == 2) //2 分纸强度项
|
||
|
m_menu->setcurindex(reg.param.func_feed_high?7:(reg.param.func_feed_mid?8:9)); //7 分纸强度高 8 分纸强度中 9 分纸强度弱
|
||
|
else if(keyvalye == (int)KeyMonitor::HGKey::Key_Menu && m_menu->getcurindex() == 4) //2 分纸强度项
|
||
|
m_menu->setcurindex(reg.param.lift_init_set == 2?20:(reg.param.lift_init_set == 1?21:22)); //7 分纸强度高 8 分纸强度中 9 分纸强度弱
|
||
|
else
|
||
|
m_menu->option(keyvalye);
|
||
|
if(m_menu->getcurindex() >=7 && m_menu->getcurindex()<= 23)
|
||
|
m_discenter->PutMsg(m_menu->getcurtype(),0,ClearScreen::BOT);
|
||
|
else
|
||
|
m_discenter->PutMsg(m_menu->getcurtype(),0,ClearScreen::All);
|
||
|
break;
|
||
|
}
|
||
|
case KeyMonitor::HGKey::Key_Clear:
|
||
|
{
|
||
|
clearcount();
|
||
|
if(m_discenter->getcurdistype() == DisType::Dis_Count_Page || m_discenter->getcurdistype() == DisType::Dis_Scan_Page)
|
||
|
m_discenter->PutMsg(DisType::Dis_Count_Page,0,ClearScreen::BOT);
|
||
|
break;
|
||
|
}
|
||
|
default:
|
||
|
break;
|
||
|
}
|
||
|
value = 0;
|
||
|
m_regs->read(0x6, value);
|
||
|
m_regs->write(0x6, value | 128);
|
||
|
m_regs->write(0x6, value & 0xffffff7f);
|
||
|
};
|
||
|
m_keymonitor.reset(new KeyMonitor(keycall));
|
||
|
}
|
||
|
|
||
|
StateControl::~StateControl()
|
||
|
{
|
||
|
uint value;
|
||
|
m_regs->read(0x06,value);
|
||
|
reg6 func = *(reg6*)&value;
|
||
|
func.param.key_stop_enable = true;
|
||
|
m_regs->write(0x06,func.value);
|
||
|
func.param.key_stop_enable = false;
|
||
|
m_regs->write(0x06,func.value);
|
||
|
if(m_menu.get())
|
||
|
m_menu.reset();
|
||
|
if(m_discenter.get())
|
||
|
m_discenter.reset();
|
||
|
if(m_keymonitor.get())
|
||
|
m_keymonitor.reset();
|
||
|
}
|
||
|
|
||
|
void StateControl::PutMsg(DisType type,int value,ClearScreen clearscreen)
|
||
|
{
|
||
|
if(m_discenter)
|
||
|
{
|
||
|
if(type == DisType::Dis_Idel)
|
||
|
{
|
||
|
uint value = 0;
|
||
|
m_regs->read(0x6,value);
|
||
|
auto tmp = *(reg6*)&value;
|
||
|
switch (tmp.param.work_mode)
|
||
|
{
|
||
|
case 1:
|
||
|
m_discenter->PutMsg(DisType::Dis_Set_Count,0,ClearScreen::All);
|
||
|
m_discenter->PutMsg(DisType::Dis_Scan_Page,getpapercount(),ClearScreen::BOT);
|
||
|
return ;
|
||
|
case 5:
|
||
|
m_discenter->PutMsg(DisType::Dis_HandMode,0,ClearScreen::All);
|
||
|
return;
|
||
|
default:
|
||
|
m_discenter->PutMsg(type,value,clearscreen);
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
m_discenter->PutMsg(type,value,clearscreen);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void StateControl::menu_func(DisType type)
|
||
|
{
|
||
|
uint value = 0;
|
||
|
MotorboardParam func_feed;
|
||
|
m_regs->read(0x6,value);
|
||
|
auto tmp = *(reg6*)&value;
|
||
|
switch (type)
|
||
|
{
|
||
|
case DisType::Dis_Set_Poweroff:
|
||
|
system("poweroff");
|
||
|
break;
|
||
|
case DisType::Dis_Set_ClearPaperPass:
|
||
|
tmp.param.func_clean_passthro = 1;
|
||
|
m_regs->write(0x6,tmp.value);
|
||
|
tmp.param.func_clean_passthro = 0;
|
||
|
m_regs->write(0x6,tmp.value);
|
||
|
break;
|
||
|
case DisType::Dis_Set_PollPI_High:
|
||
|
tmp.param.func_feed_high = 1;
|
||
|
tmp.param.func_feed_low = tmp.param.func_feed_mid = 0;
|
||
|
m_regs->write(0x6,tmp.value);
|
||
|
func_feed.GetOrSetFeedMode(false,2);
|
||
|
break;
|
||
|
case DisType::Dis_Set_PollPI_Mid:
|
||
|
tmp.param.func_feed_mid = 1;
|
||
|
tmp.param.func_feed_low = tmp.param.func_feed_high = 0;
|
||
|
m_regs->write(0x6,tmp.value);
|
||
|
func_feed.GetOrSetFeedMode(false,1);
|
||
|
break;
|
||
|
case DisType::Dis_Set_PollPI_Low:
|
||
|
tmp.param.func_feed_low = 1;
|
||
|
tmp.param.func_feed_mid = tmp.param.func_feed_high = 0;
|
||
|
m_regs->write(0x6,tmp.value);
|
||
|
func_feed.GetOrSetFeedMode(false,0);
|
||
|
break;
|
||
|
case DisType::Dis_Set_SleepMode_5M:
|
||
|
if(m_wake.get())
|
||
|
m_wake->settime(300);
|
||
|
break;
|
||
|
case DisType::Dis_Set_SleepMode_10M:
|
||
|
if(m_wake.get())
|
||
|
m_wake->settime(600);
|
||
|
break;
|
||
|
case DisType::Dis_Set_SleepMode_20M:
|
||
|
if(m_wake.get())
|
||
|
m_wake->settime(1200);
|
||
|
break;
|
||
|
case DisType::Dis_Set_SleepMode_30M:
|
||
|
if(m_wake.get())
|
||
|
m_wake->settime(1800);
|
||
|
break;
|
||
|
case DisType::Dis_Set_SleepMode_1H:
|
||
|
if(m_wake.get())
|
||
|
m_wake->settime(3600);
|
||
|
break;
|
||
|
case DisType::Dis_Set_SleepMode_2H:
|
||
|
if(m_wake.get())
|
||
|
m_wake->settime(7200);
|
||
|
break;
|
||
|
case DisType::Dis_Set_SleepMode_4H:
|
||
|
if(m_wake.get())
|
||
|
m_wake->settime(14400);
|
||
|
break;
|
||
|
case DisType::Dis_Set_SleepMode_NEVER:
|
||
|
if(m_wake.get())
|
||
|
m_wake->settime(-1);
|
||
|
break;
|
||
|
case DisType::Dis_Set_TrayPosition_High:
|
||
|
tmp.param.lift_init_set = 2;
|
||
|
m_regs->write(0x6,tmp.value);
|
||
|
func_feed.GetOrSetTrayPosition(false,2);
|
||
|
break;
|
||
|
case DisType::Dis_Set_TrayPosition_Mid:
|
||
|
tmp.param.lift_init_set = 1;
|
||
|
m_regs->write(0x6,tmp.value);
|
||
|
func_feed.GetOrSetTrayPosition(false,1);
|
||
|
break;
|
||
|
case DisType::Dis_Set_TrayPosition_Low:
|
||
|
tmp.param.lift_init_set = 0;
|
||
|
m_regs->write(0x6,tmp.value);
|
||
|
func_feed.GetOrSetTrayPosition(false,0);
|
||
|
break;
|
||
|
default:
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void StateControl::lcdcontrol(int led){
|
||
|
if(m_keymonitor)
|
||
|
m_keymonitor->setled((KeyMonitor::HGLed)led);
|
||
|
}
|
||
|
|
||
|
void StateControl::setrunstate(bool value)
|
||
|
{
|
||
|
is_runing = value;
|
||
|
if(is_runing){
|
||
|
m_keymonitor->setled(KeyMonitor::HGLed::Led_Enter_open);
|
||
|
m_menu->setcurindex(0);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
uint value = 0;
|
||
|
m_regs->read(0x6,value);
|
||
|
auto tmp = *(reg6*)&value;
|
||
|
m_keymonitor->setled(tmp.param.key_endouble_feed?KeyMonitor::HGLed::Led_DoubleFeed_open : KeyMonitor::HGLed::Led_DoubleFeed_close);
|
||
|
m_keymonitor->setled(KeyMonitor::HGLed::Led_Enter_close);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool StateControl::getrunstate()
|
||
|
{
|
||
|
return is_runing;
|
||
|
}
|
||
|
|
||
|
void StateControl::setcoverstate(bool value)
|
||
|
{
|
||
|
is_cover_open = value;
|
||
|
}
|
||
|
bool StateControl::getcoverstate()
|
||
|
{
|
||
|
return is_cover_open;
|
||
|
}
|
||
|
void StateControl::setmenuindex(int menu){
|
||
|
m_menu->setcurindex(menu);
|
||
|
}
|
||
|
|
||
|
uint StateControl::getpapercount(){
|
||
|
unsigned int papercount = 0;
|
||
|
m_regs->read(0x02,papercount);
|
||
|
printf("\nmotorcount = %d ",papercount&0x3fff);
|
||
|
return papercount&0x3fff;
|
||
|
}
|
||
|
|
||
|
void StateControl::clearcount(){
|
||
|
uint value = 0;
|
||
|
m_regs->read(0x6,value);
|
||
|
auto reg = *(reg6*)&value;
|
||
|
reg.param.func_clear_count = 1;
|
||
|
m_regs->write(0x6,reg.value);
|
||
|
reg.param.func_clear_count = 0;
|
||
|
m_regs->write(0x6,reg.value);
|
||
|
}
|
||
|
|
||
|
void StateControl::setautopaperflag(bool enable,bool enkey){
|
||
|
is_autopaper = enable;
|
||
|
en_autopaper_key = enkey;
|
||
|
}
|
||
|
|
||
|
void StateControl::setautopaperstopcallback(std::function<void()> func)
|
||
|
{
|
||
|
if(func)
|
||
|
autopaperstop = func;
|
||
|
}
|