C++之doorhelper

doorhelper.h&doorhelper.cpp

1)doorhelper.h
代码:
#ifndef DOORHELPER_H
#define DOORHELPER_H

#include
#include
#include
#include
#include
#include “OpenDoorTimeSpan.h”

typedef enum
{
OPENRUN = 0,
CLOSERUN,
STOPRUN,
}State;

class DoorHelper: public QObject
{
Q_OBJECT

public:

 DoorHelper();//构造函数
//DoorHelper();
~DoorHelper();//析构函数
void ringcit();
void OpenDoor(QString userId="");
void OpenMotorDoor();
int OpenRelayDoor();
void AutoOpenDoor();
void AutoCloseDoor();
void AutoOpenMotorDoor();
void AutoOpenRelayDoor();
void AutoCloseMotorDoor();
void AutoCloseRelayDoor();
bool IsAutoTimeSpan();
void SetDoorConfig(int newDoorType,int newDoorTurnTime,int newDoorDelay,int newDoorEnable,int newDoorTpype1Switch,QList<OpenDoorTimeSpan> newOpenDoorTimeSpanList,int newRingDelay)
{
    doorType =newDoorType; //门禁类型
    doorTurnTime =newDoorTurnTime;//电机驱动时常
    doorDelay =newDoorDelay;//门禁延时
    doorEnable = newDoorEnable;//是否使用门禁
    doorTpype1Switch = newDoorTpype1Switch ;//继电器K1 or K2 0:K1 1:K2
    openDoorTimeSpanList = newOpenDoorTimeSpanList;
    ringDelay=newRingDelay;
}


void SetOpenDoorTimeSpan(QList<OpenDoorTimeSpan> newOpenDoorTimeSpanList)
{
    openDoorTimeSpanList = newOpenDoorTimeSpanList;
}

bool SendWeigen(uint InputCardNO);
int getDoorEnable();
void SendWiegand(uint hidh, uint hidl, uint pidh, uint pidl);
void SendWiegand_old(uint hidh, uint hidl, uint pidh, uint pidl);
void SendWiegand_new(uint hidh, uint hidl, uint pidh, uint pidl);

private slots:
void timerFinished();
void taskTimerDispose();
void ringstop();

private:
int doorTpype1Switch ;
int doorTpype1Switchbak;
int ringnum;

int fd_am335x_gpio;
bool opening ;
int controlStep ;
int doorType ; //门禁类型 0:电机 1:继电器
int doorTurnTime ;//电机驱动时常
int doorDelay;//门禁延时
int doorEnable ;//是否使用门禁
int ringDelay;

//继电器K1 or K2 0:K1 1:K2
QList openDoorTimeSpanList ;
QTimer *doorWaitTimer;
QTimer *taskTimer ;
QTimer *ringtime;
bool doorIsOpen;
bool isAutoOpen ;

int fn_am335x_gpio_init(void);
int fn_set_am335x_gpio_value(int gpio_num,int value);
int fn_am335x_gpio_exit(void);
void OpenMotor(State state_);
int OpenRelay(int relayNum, int relayState);

};

#endif // DOORHELPER_H

2)doorhelper.cpp
//代码:
#include “doorhelper.h”
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include"config.h"

//定义燕南D500设备参数
#if(YANNAN)
#define DEVICE_NAME “/dev/am335x-gpio”
#define MOTOR_MAGIC ‘g’
#define SET_GPIO_DIRECT (_IOW(MOTOR_MAGIC, 0,int))
#define SET_GPIO_VALUE_BASE (_IOW(MOTOR_MAGIC, 0,int)+200)
#define GET_GPIO_VALUE_BASE (_IOW(MOTOR_MAGIC, 0,int)+400)

#define GPIO_NUM 7

static int gpio_num[GPIO_NUM] = {
	1*32+17,	//GPMC_A1 电机1脚
	1*32+18,	//GPMC_A2 电机2脚
	1*32+19,    //GPMC_A3 继电器 k1
	1*32+20,    //GPMC_A4 继电器 k2
	0,                //无效
	0*32+4,  //SPI0_D1
	1*32+12,    //GPMC_AD12
 };

#endif

//定义防爆AF251产品参数
#if(fangbao)
#define M_GPIO_OUTPUT 0
#define M_GPIO_INPUT 1
#define M_GPIO_OUTPUT_HIGH 1
#define M_GPIO_OUTPUT_LOW 0

#define DEVICE_NAME "/dev/led"
#define MOTOR_MAGIC 'g'
#define SET_GPIO_DIRECT                 (_IOW(MOTOR_MAGIC, 0,int))
#define SET_GPIO_VALUE_BASE 		(_IOW(MOTOR_MAGIC, 0,int)+200)
#define GET_GPIO_VALUE_BASE 		(_IOW(MOTOR_MAGIC, 0,int)+400)

#define GPIO_NUM 7

static int gpio_num[GPIO_NUM] = {
	1*32+17,	//GPMC_A1 电机1脚
	1*32+18,	//GPMC_A2 电机2脚
	0x201,    //GPMC_A3 继电器 k1
	0x007,    //GPMC_A4 继电器 k2
	0x200,   // 设置韦根输入输出状态 1:输出 0:输入
	0x302,  //韦根D0      0高电平 1低电平
	0x301,  //韦根D1      0高电平 1低电平
};

#endif

//定义竖屏AF252产品参数
#if(shuping)

struct gpio_ops {
	int in;
	int data;
};

#define DEVICE_NAME "/dev/gpio"
#define AWTS   'x'
#define GPIO0  _IOR(AWTS,0,int)
#define GPIO1  _IOR(AWTS,1,int)
#define GPIO2  _IOR(AWTS,2,int)
#define GPI03   _IOR(AWTS,3,int)
#define GPI04   _IOR(AWTS,4,int)

#define GPIO_NUM 7

static int gpio_num[GPIO_NUM] = {
	GPI03,	//GPMC_A1 电机1脚
	GPI04,	//GPMC_A2 电机2脚
	GPI03,    //GPMC_A3 继电器 k1
	GPI04,    //GPMC_A4 继电器 k2
	GPIO0,    //设置韦根输入输出状态 1:输出 0:输入
	GPIO1,  //韦根D0      0高电平 1低电平
	GPIO2,  //韦根D1      0高电平 1低电平
};

#endif

//定义通用接口参数
#define WG_OUT fn_set_am335x_gpio_value(gpio_num[4],1);
#define WG_DATA0_0 fn_set_am335x_gpio_value(gpio_num[5],0)
#define WG_DATA1_0 fn_set_am335x_gpio_value(gpio_num[6],0)
#define WG_DATA0_1 fn_set_am335x_gpio_value(gpio_num[5],1)
#define WG_DATA1_1 fn_set_am335x_gpio_value(gpio_num[6],1)

DoorHelper::DoorHelper()
{
// //load driver (delete by heyu,because the new linix set already load this driver)
// char command[100];
// strncpy(command, QString(“insmod /opt/AC/bin/am335x-gpio.ko”).toStdString().c_str(), sizeof(command));
// system(command);

opening = false;
doorIsOpen = false ;
isAutoOpen = false;
doorWaitTimer = new QTimer();
ringtime=new QTimer();
bool a = connect(doorWaitTimer, SIGNAL(timeout()), this, SLOT(timerFinished()));
if(a)
controlStep =0;

taskTimer = new QTimer();
connect(taskTimer, SIGNAL(timeout()), this, SLOT(taskTimerDispose()));
connect(ringtime,SIGNAL(timeout()),this, SLOT(ringstop()));
taskTimer->start(10000);
if(fn_am335x_gpio_init() == -1)
 {
     opening = false ;
     qDebug()<<"door_open_error";

 }

}

DoorHelper::~DoorHelper()
{
delete doorWaitTimer;
delete taskTimer;
delete ringtime;
fn_am335x_gpio_exit();
}

int DoorHelper::fn_am335x_gpio_init(void)
{
fd_am335x_gpio = open(DEVICE_NAME, 0);
if (fd_am335x_gpio < 0)
{
qDebug()<<QString(“open device am335x-gpio error”);

    perror("open device am335x-gpio error");
    return -1;
}

else
{

}

 fn_set_am335x_gpio_value(gpio_num[2],0);
 fn_set_am335x_gpio_value(gpio_num[3],0);

return 0;

}

int DoorHelper::fn_set_am335x_gpio_value(int gpio_num,int value)
{

int ret=-1;

#if(YANNAN)
ret= ioctl(fd_am335x_gpio,SET_GPIO_VALUE_BASE+gpio_num,value);
#endif
#if (fangbao)
ret=ioctl(fd_am335x_gpio,value,gpio_num);
#endif
#if(shuping)
struct gpio_ops data;
data.in=0;
data.data=value;
ret=ioctl(fd_am335x_gpio,gpio_num,&data);
if(ret!=0){
perror(“ioctl:set value error”);

}

#endif
return ret;
}

int DoorHelper::fn_am335x_gpio_exit(void)
{
if (fd_am335x_gpio != 0)
{
close(fd_am335x_gpio);
return 0;
}
return -1;
}

/*
*开电机锁
*/

void DoorHelper::OpenMotor(State state_)
{
//gpio初始化
if(fn_am335x_gpio_init() == -1)
{
opening = false ;
return ;
}

State state = state_;
printf("%d\n",state);

if(state != OPENRUN && state != CLOSERUN && state != STOPRUN)
{
    printf("OpenRelay:Pleale input the true motor state!\n");
    exit(1);
}

switch(state)
{
    case OPENRUN://电机正转，停转后实现开门
        fn_set_am335x_gpio_value(gpio_num[0],1);
        fn_set_am335x_gpio_value(gpio_num[1],0);
        printf("switch OPENRUN:%d\n",state);
        break;
    case CLOSERUN://电机反转，停转后实现关门
        fn_set_am335x_gpio_value(gpio_num[0],0);
        fn_set_am335x_gpio_value(gpio_num[1],1);
        printf("switch CLOSERUN:%d\n",state);
        break;
    case STOPRUN://电机停转
        fn_set_am335x_gpio_value(gpio_num[0],0);
        fn_set_am335x_gpio_value(gpio_num[1],0);
        printf("switch STOPRUN:%d\n",state);
        break;
}

fn_am335x_gpio_exit();

}

/*
*开继电器锁
*relayNum :D500包括两个继电器，此为选择继电器参数

•      0　对应　继电器 k1;  1　对应　继电器　k2
  

*/
int DoorHelper::OpenRelay(int relayNum, int relayState)
{
qDebug()<<“relayState”<<relayState;
qDebug()<<" relayNum"<< relayNum;
if( (relayNum <0) && (relayNum >5))
{
printf(“relayNum: 0 - > K1.\n”);
printf(“relayNum: 1 - > K2.\n”);
return -1;
}

if( (relayState != 0) && (relayState != 1) )
{
    printf("relayState: 0 power low level.\n");
    printf("relayState: 1 power high level.\n");
    return -1;
}
 int ret=fn_set_am335x_gpio_value(gpio_num[relayNum + 2],relayState);
if(ret!=0){
    qDebug()<<"gpio set failed:"<<ret;
}
return ret;

}

void DoorHelper::OpenMotorDoor()
{
qDebug()<<QString(“open motor door”);

OpenMotor(OPENRUN);//电机正转,开门



//OpenMotor(CLOSERUN);//反转,准备关门
//wait for stop turn
controlStep = 1;
//doorWaitTimer->connect(this, SIGNAL(timeout()), this, SLOT(timerFinished()));
doorWaitTimer->start(doorTurnTime);

}

void DoorHelper::AutoOpenMotorDoor()
{
qDebug()<<QString(“auto open motor door”);

OpenMotor(OPENRUN);//电机正转,开门

controlStep = 4;
doorWaitTimer->start(doorTurnTime);

}

int DoorHelper::OpenRelayDoor()
{
qDebug()<<QString(“open relay door,switch:%1”).arg(QString::number(doorTpype1Switch));

//继电器 K1 高电平 开门

OpenRelay(doorTpype1Switch, 1);

doorIsOpen = true ;
controlStep = 1;
doorWaitTimer->start(doorDelay);

}

void DoorHelper::AutoOpenRelayDoor()
{
qDebug()<<QString(" auto open relay door,switch:%1").arg(QString::number(doorTpype1Switch));

//继电器 K1 高电平 开门
OpenRelay(doorTpype1Switch, 1);

doorIsOpen = true;

}

void DoorHelper::OpenDoor(QString userId)
{
qDebug()<<“opendoor id:”<<userId;
if(!this->IsAutoTimeSpan())
{
qDebug()<<“open time not in timespan”;
return;
}

if(!doorEnable)
{
    qDebug()<<QString("door contorl disable ,return");
    return ;
}

if(isAutoOpen)
{
    qDebug()<<QString("in door auto open state ,return");
    return ;
}

if(opening)
{
    qDebug()<<QString("door opening ,return");
    return ;
}

opening = true ;

u_int32_t weigenid=0;

switch (doorType)
{

case 0:
     OpenRelayDoor();
  //  OpenMotorDoor();
    break;
case 1:
   // OpenRelayDoor();
    if(userId=="")
        return;
      opening = false ;

#if(YANNAN)
weigenid = userId.toUInt();
SendWiegand(weigenid/ 65536, weigenid% 65536, weigenid/ 256, weigenid% 256) ;
#else
SendWeigen(userId.toUInt());
#endif
break;
default:
break;
}

}

bool DoorHelper::IsAutoTimeSpan()
{
foreach (OpenDoorTimeSpan openDoorTimeSpan, openDoorTimeSpanList)
{
QTime current = QTime::currentTime();
if(current >= openDoorTimeSpan.startTime && current <= openDoorTimeSpan.endTime)
{
return true;
}
}

return false ;

}

bool DoorHelper::SendWeigen(uint InputCardNO)
{
uchar str[3];
//str[0] = hid;
//str[1] = pidHigh;
//str[2] = pidLow;
uchar Wiegand[3];//wiegand26信号三个字节的数据
uchar Str[] = {0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};
uint i,j;
uint even;//韦根包前12位偶效验
uint odd;//韦根包后12位奇效验
uchar Check_temp;//中间变量
useconds_t time100 = 100;
useconds_t time1500 = 1500;
//--------------------------
str[0] = InputCardNO / 65536;
i = InputCardNO % 65536;
str[1] = i / 256;
str[2] = i % 256;
//--------------------------
// uchar str[] = {0,0,0};
// str = num;
printf("%x,%x,%x\n",str,(str + 1),(str + 2));
qDebug()<<str<<" "<<(str + 1)<<" "<<(str + 2);

// fn_am335x_gpio_init();
// sleep(3);

for(i = 0; i < 3; i++)
{
    Wiegand[i] = *(str + i);
    printf("Wiegand[%d]:%d\n",i,*(str + i));
}
//----------------------------计算前12位数据中的偶校验位
Check_temp = ((Wiegand[0] & 0x80) >> 7) + ((Wiegand[0] & 0x40) >> 6) + ((Wiegand[0] & 0x20) >> 5)
    + ((Wiegand[0] & 0x10) >> 4) + ((Wiegand[0] & 0x08) >> 3) + ((Wiegand[0] & 0x04) >> 2)
    + ((Wiegand[0] & 0x02) >> 1) + (Wiegand[0] & 0x01) + ((Wiegand[1] & 0x80) >> 7)
    + ((Wiegand[1] & 0x40) >> 6) + ((Wiegand[1] & 0x20) >> 5) + ((Wiegand[1] & 0x10) >> 4);
if((Check_temp & 0x01) == 1)
    even = 1;
else even = 0;

qDebug()<<"Check_temp:"<<Check_temp;
//----------------------------计算后12位数据中的奇校验位
Check_temp = ((Wiegand[1] & 0x08) >> 3) + ((Wiegand[1] & 0x04) >> 2) + ((Wiegand[1] & 0x02) >> 1)
    + (Wiegand[1] & 0x01) + ((Wiegand[2] & 0x80) >> 7) + ((Wiegand[2] & 0x40) >> 6)
    + ((Wiegand[2] & 0x20) >> 5) + ((Wiegand[2] & 0x10) >> 4) + ((Wiegand[2] & 0x08) >> 3)
    + ((Wiegand[2] & 0x04) >> 2) + ((Wiegand[2] & 0x02) >> 1) + (Wiegand[2] & 0x01);
if(Check_temp & 0x01 == 1)
    odd = 0;
else odd = 1;
//----------------------------发送数据
//----------------------------初始化Wiegand端口

#if(!YANNAN)
WG_OUT;
#endif
WG_DATA0_1;
WG_DATA1_1;
//----------------------------发送偶校验
if(even)
{
WG_DATA1_0;
}
else
{
WG_DATA0_0;
}
//----------延时100us，用定时器0来定时
usleep(time100);

    if(even)
    {
        WG_DATA1_1;
    }
    else
    {
        WG_DATA0_1;

    }

// //--------------延时一个发送周期
usleep(time1500);
//----------------------------发送24位数据
for(i = 0; i < 3; i++)
for(j = 0; j < 8; j++)
{
if(Wiegand[i] & Str[j])
{
WG_DATA1_0;
}
else
{
WG_DATA0_0;
}
//----------延时100us，用定时器0来定时
usleep(time100);
if(Wiegand[i] & Str[j])
{
WG_DATA1_1;
}
else
{WG_DATA0_1;
}
//--------------延时一个发送周期
usleep(time1500);
}
//----------------------------发送奇校验
if(odd)
{
WG_DATA1_0;
}
else
{
WG_DATA0_0;
}
//----------延时100us，用定时器0来定时
usleep(time100);
if(odd)
{
WG_DATA1_1;
}
else
{
WG_DATA0_1;
}
//--------------延时一个发送周期
usleep(time1500);

// fn_am335x_gpio_exit();

}

void DoorHelper::SendWiegand(uint hidh, uint hidl, uint pidh, uint pidl)
{
if(QFile::exists("/dev/GpioTestDriver"))
{
qDebug()<<“old wiegand …”;
SendWiegand_old(hidh, hidl, pidh, pidl);
}
else if(QFile::exists("/dev/WiegandDriver"))
{
qDebug()<<“new wiegand …”;
SendWiegand_new(hidh, hidl,pidh, pidl);
}
else
{
qDebug()<<“no wiegand …”;
}
}

void DoorHelper::SendWiegand_old(uint hidh, uint hidl, uint pidh, uint pidl)
{
int wiegandfd = -1;
wiegandfd = open("/dev/GpioTestDriver", O_RDWR);

//unsigned char wiegandbuf[3] = { hidl, pidh, pidl };
unsigned char wiegandbuf[4] =
{ hidh, hidl, pidh, pidl };

//ioctl(wiegandfd, 3, wiegandbuf);
ioctl(wiegandfd, 4, wiegandbuf);
close(wiegandfd);

}

void DoorHelper::SendWiegand_new(uint hidh, uint hidl, uint pidh, uint pidl)
{
#define WIEGAND34
//#define WIEGAND26
int wiegandfd = -1;
wiegandfd = open("/dev/WiegandDriver", O_RDWR);

#ifdef WIEGAND34
unsigned char wiegandbuf[4] =
{ hidh, hidl, pidh, pidl };
ioctl(wiegandfd, 34, wiegandbuf);
#else
unsigned char wiegandbuf[3] = { hidl, pidh, pidl };
ioctl(wiegandfd, 26, wiegandbuf);
#endif
close(wiegandfd);
}

void DoorHelper::taskTimerDispose()
{
bool newAutoOpenState = IsAutoTimeSpan();

if(newAutoOpenState == isAutoOpen)
    return ;
return ;

isAutoOpen = newAutoOpenState;
if(isAutoOpen)
{
    AutoOpenDoor() ;
}
else
{
    AutoCloseDoor();
}

}

void DoorHelper::AutoOpenDoor()
{
if(!doorEnable)
{
qDebug()<<QString(“door contorl disable ,return”);
return ;
}

if(doorIsOpen)
    return ;

qDebug()<<QString("door auto open");



switch (doorType)
{
case 0:
 //   AutoOpenMotorDoor();
      AutoOpenRelayDoor();
    break;
case 1:
    AutoOpenRelayDoor();
    break;
default:
    break;
}

}

void DoorHelper::AutoCloseDoor()
{
if(!doorIsOpen)
return ;

qDebug()<<QString("door auto close");



switch (doorType)
{
case 0:
    AutoCloseMotorDoor();
    break;
case 1:
    AutoCloseRelayDoor();
    break;
default:
    break;
}

}

void DoorHelper::AutoCloseMotorDoor()
{
OpenMotor(CLOSERUN);//反转,准备关门
controlStep = 5;
doorWaitTimer->start(doorTurnTime);
}

void DoorHelper::AutoCloseRelayDoor()
{
qDebug()<<QString(“auto close door,switch:%1”).arg(QString::number(doorTpype1Switch));
OpenRelay(doorTpype1Switch, 0);
}

void DoorHelper::timerFinished()
{
doorWaitTimer->stop();
if(doorType ==3)
{
//电机
switch (controlStep) {
case 1:
qDebug()<<QString(“setp 1,stop turn ,door open”);
OpenMotor(STOPRUN);//停转　此时是开门状态
controlStep = 2 ;
doorIsOpen = true ;
doorWaitTimer->start(doorDelay);//保持开门状态的时间
break;
case 2:
qDebug()<<QString(“setp 2,begin close door”);
OpenMotor(CLOSERUN);//反转,准备关门
controlStep = 3;
doorWaitTimer->start(doorTurnTime);
break;
case 3:
qDebug()<<QString(“setp 3,close door”);
OpenMotor(STOPRUN);//此时关门,操作结束
controlStep = 0;
opening = false;
doorIsOpen = false ;
break;
case 4:
OpenMotor(STOPRUN);//停转　此时是开门状态
doorIsOpen = true;
break;
case 5:
OpenMotor(STOPRUN);//此时关门,操作结束
doorIsOpen = false;
break;
default:
break;
}
}
else if(doorType == 0)
{
switch (controlStep) {
case 1:
// 继电器 低电平 关门
qDebug()<<QString(“setp 1,close door,switch:%1”).arg(QString::number(doorTpype1Switch));
OpenRelay(doorTpype1Switch, 0);
// fn_am335x_gpio_exit();
controlStep = 0;
opening = false;
doorIsOpen = false ;
break;
default:
break;
}
}

}
void DoorHelper::ringcit()
{
if(this->doorTpype1Switch==0)
{
doorTpype1Switchbak=1;
}
else
{
doorTpype1Switchbak=0;
}

fn_set_am335x_gpio_value(gpio_num[doorTpype1Switchbak+2],1);
ringtime->start(ringDelay);

}
void DoorHelper::ringstop()
{
fn_set_am335x_gpio_value(gpio_num[doorTpype1Switchbak+2],0);
ringtime->stop();

}

int DoorHelper::getDoorEnable()
{
return doorEnable;
}