lmh188
/
rk3399_arm_lvds
mirror of http://192.168.1.51:8099/gxx_linux/rk3399_arm_lvds.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
rk3399_arm_lvds/motorcontroller/StateControl.cpp

473 lines
16 KiB
C++
Raw Blame History

#include "MenuComponent.h"
#include "DisplayCenter.h"
#include "keymonitor.h"
#include "regsaccess.h"
#include "StateControl.h"
#include "wakeup.hpp"
#include "MotorboardParam.h"
#include "jsonconfig.h"
#include "deviceconfig.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*)&reg6value;
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;
reg.param.motor_disable = false;
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:
{
reg6 func = {0};
m_regs->read(0x06,func.value);
m_regs->read(0x0a,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;
func.param.motor_disable = value > 0 ? true: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?9:(reg.param.func_feed_mid?10:11)); //8分纸强度高 9 分纸强度中 10 分纸强度弱
else if(keyvalye == (int)KeyMonitor::HGKey::Key_Menu && m_menu->getcurindex() == 4) //2 分纸强度项
m_menu->setcurindex(reg.param.lift_init_set == 2?22:(reg.param.lift_init_set == 1?23:24)); //7 分纸强度高 8 分纸强度中 9 分纸强度弱
else
m_menu->option(keyvalye);
if(m_menu->getcurindex() >=26 && m_menu->getcurindex()<= 27)
{
m_discenter->PutMsg(m_menu->getcurtype(),
m_menu->getcurindex() ==26 ? Get_static_jsonconfig().getmemparam().RollerNum : Get_static_jsonconfig().getmemparam().TotalScanned,ClearScreen::BOT);
}
else if(m_menu->getcurindex() >=9 && m_menu->getcurindex()<= 36)
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;
tmp.param.motor_disable = false;
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;
case DisType::Dis_Set_Clear_Roller_ScanNum:
{
PutMsg(DisType::Dis_Set_Is_Sure,0,ClearScreen::BOT);
break;
}
case DisType::Dis_Set_YES:
{
if(m_menu->getcurindex() == 30)
{
auto tmp = Get_static_jsonconfig().getscannerinfo();
tmp.RollerNum =0;
Get_static_jsonconfig().savescannerinfo(tmp);
PutMsg(DisType::Dis_Set_ScanNum_Option,0,ClearScreen::TOP);
}
break;
}
case DisType::Dis_Set_No:
{
if(m_menu->getcurindex() == 31)
PutMsg(DisType::Dis_Set_ScanNum_Option,0,ClearScreen::TOP);
break;
}
case DisType::Dis_Set_Item_Return:
{
if(m_menu->getcurindex() == 32)
PutMsg(DisType::Dis_Set_ScanNum_Option,0,ClearScreen::TOP);
break;
}
case DisType::Dis_Language_Chinese:
{
auto param = Get_static_deviceconfig().GetParam();
if(param.language!=0){
param.language = 0;
Get_static_deviceconfig().SaveParam(param);
}
m_discenter->set_language(LCDDisplay::Language::Chinese);
break;
}
case DisType::Dis_Language_Chinese_Traditional:
{
auto param = Get_static_deviceconfig().GetParam();
if(param.language!=1){
param.language = 1;
Get_static_deviceconfig().SaveParam(param);
}
m_discenter->set_language(LCDDisplay::Language::TraditionalChinese);
break;
}
case DisType::Dis_Language_English:
{
auto param = Get_static_deviceconfig().GetParam();
if(param.language!=2){
param.language = 2;
Get_static_deviceconfig().SaveParam(param);
}
m_discenter->set_language(LCDDisplay::Language::English);
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;
}
Reference in New Issue View Git Blame Copy Permalink