QT智能小车

最新推荐文章于 2023-06-15 16:50:52 发布
最新推荐文章于 2023-06-15 16:50:52 发布
阅读量1.3k 收藏 13
点赞数
文章标签： qt c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47073762/article/details/127014679
版权

 一、系统界面

二、主要代码

运用多线程实现多辆小车的正常运行

运用  QTimer定时器控制交通灯的变换

头文件

1.car.h

#ifndef CAR_H
#define CAR_H
#include "mainwindow.h"
#include <QThread>
#include <QTime>
#include <QCoreApplication>
#include <QEventLoop>
#include <iostream>
#include "position.h"

using namespace std;
class Car : public QThread

{
    Q_OBJECT
public :
    Car();
    Car(MainWindow *gui,int i,int x,int y, int width, int height);
   ~Car();


    MainWindow *pMain;

    int eastbar;
    int westbar;
    int carnumber;
    int dir;
    int position_x;
    int position_y;
    int position_width;
    int position_height;
    int bar;
    QString carlicense;
    QString carmoney;
     QString carmoney2;
    QString carmodel;
    int car_x;
    int car_y;
    int car_width;
    int car_height;
    int mx;
    int my;
    int park_x;
    int park_y;
    int init_car_x;
    int init_car_y;
    void run();
    void run_in();
    void sleep(int t);
    void FencesPower(int i);  //栅栏控制
    void redEnterCheck(int i);//红外检测入口栅栏何时关闭
    void setCarInfo(QString carName,QString money,QString brand);//设置小车信息
    void stopCarTime(unsigned int msec);    //停车时间
    void scanCar(int i);                         //扫描仪扫描小车信息
    void cheatPark();                       //诱导停车
    void wheel();                           //车辆转弯
    void stopPark();                        //车位停车
    void walkExit();
    void walkFangxiangToExit();
    void exitPark();
    QString  getCarlicense();
    QString  getCarmoney();
    QString  getCarmodel();
    void stop();

signals:
    void update(int i,int x,int y, int width, int height);
    void Fence_Update(int i);
    void trans_update(int i,unsigned int ang);
    void show_update(int i,QString str);

public slots:
    void slotUpdate(int i,int x,int y, int width, int height);
    void FenceUpdate(int i);
    void transUpdate(int i, unsigned int angle);
    void showUpdate(int i, QString carInfo);
};




#endif // CAR_H

2.mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QTime>
#include <QApplication>
#include <QDebug>
#include <string>
#include <qfile.h>
#include <qtextstream.h>
#include <iostream>
#include <QDateTime>
#include<fstream>
#include<map>
#include <QTimer>
#include <QLabel>
#define INSTANCE 3
#define STOP 1
#define RUN 2





using namespace std;
namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
    void lightOn(QLabel *label);
    void lightOff(QLabel *label);
    void wheel();
    void TurnPower(int x,int y);
    void turnLeft();
    void throughLight();
    void stop();
    void run();
    void mysleep(unsigned int msec);
    void parking();
    void FencesEnterOn();                   //入口栅栏开
    void FencesEnterOff();                  //入口栅栏关
    void FencesExitOn();                    //出口栅栏开
    void FencesExitOff();                   //出口栅栏关
    void writeTofile(QString carInfo);      //将小车信息写入文件函数
    void splitCarInfor(QString carInfo,vector<string>& v);  //切割小车信息
    QString readFromFile(QString path);     //返回从数据库中获取到的车位信息
    string showToEnter(QString carInfo);      //入口显示屏显示小车信息
    void showToExit(QString carInfo);      //入口显示屏显示小车信息
     void getSysTime();
    string readSqlCar();                    //读取小车的车位信息
    int judgeIsNullOfCar(QString linestr);  //判断从数据库中获取到的车位是否被占用
    void splitCarPort(string& str);
    void setParkFlag();                     //更改小车标志位
    void writeDataFile(int count);
    void initCarPort();                     //map中初始化车位和标志位
    string judgeCarPortFlag();              //判断车位标志能否停车
    string readPositionFromFile(QString path);//从文件中读指定车位的位置信息
    bool isPort(string lineStr);            //判断从文件中读到的信息与对应车位是否一致
    void setCarInfo(int num);
    void trans(int ,unsigned int );
    void updateposition(int ,int ,int ,int , int );

  void updatelight();

private slots:
    void on_pushButton_clicked();
    void onTimerOut();
private:
    string getXY(string lineStr);             //提取lineStr的xy设置mx,my
    string setWork();



private:
    Ui::MainWindow *ui;

    //car position
  int mx;//car position x
  int car_state;
  int my;//car position y
  int count;
  string mLocalTime;
  QTimer *timer;
  int settimer1;
  int settimer2;
    map<string,int> maplive;                 //车位，标志
    string mCarPort;                         //车位
    int position_x;
    int position_y;
    int position_weight;
    int position_height;
    int position_x1;
    int position_y1;
    int position_weight1;
    int position_height1;
    int position_x2;
    int position_y2;
    int position_weight2;
    int position_height2;
    QPixmap pixmap;
    QPixmap pixmap1;
    QMatrix matrix;
     QMatrix matrix1;
    QPixmap pixmap3;
    QMatrix matrix3;
    QPixmap pixmap4;
    QPixmap pixmap6;
    QPixmap pixmap5;
    QTimer *timer2;
    QTimer *timer1;
    QTimer *timer3;
    int carx;
    int carx2;
    int light;
    //Car *thread1,*thread2,*thread3,;
};

#endif // MAINWINDOW_H

3.position.h

#ifndef POSITION_H
#define POSITION_H

#define fencesEnter_x   540
#define fencesEnter_y   240

#define up   1
#define down  2
#define left  3
#define right 4
#define westbar_x 670

#define fencesExit_x    544
#define fencesExit_y    500

#define ExitRed_x     580
#define ExitRed_y     520

#define enterRed_x    580
#define enterRed_y    310

#define midLine_x     130
#define midLine_y   390

#define downStreet_x 130
#define downStreet_y 440



#define scanBtn_x     550
#define scanBtn_y   260

#define flagUp_x      130
#define flagUp_y     270

#define upStreet_x   130
#define upStreet_y   440

#define scanBtnExit_x    544
#define scanBtnExit_y   470

#define flagLineFive_x   610
#define CHECK_LENGTH 5
#define INSTANCE 2
#define leftline_x 128
#define leftline_y 230
#define downline_x 130
#define downline_y 670







#endif // POSITION_H

2.源文件

1.car.cpp

#include "car.h"
extern int isRun;
extern int flag;
extern struct PARK_POSITION park;


extern int isRun;
extern int westflag;
extern int eastflag;


Car::Car(MainWindow *gui, int i,int x,int y,int width,int height)

{     pMain=gui;
      carnumber=i;
      position_x=x;
      position_y=y;
      position_height=height;
      position_width=width;

    init_car_x=x;
    init_car_y=y;
    dir=0;
    pMain=gui;
    carnumber=i;
    car_x=x;
    car_y=y;
    car_height=height;
    car_width=width;
    connect(this,SIGNAL(update(int ,int ,int , int, int)),this,SLOT(slotUpdate(int ,int ,int , int , int )));
    connect(this,SIGNAL(Fence_Update(int)),this,SLOT(FenceUpdate(int)));
    connect(this,SIGNAL(trans_update(int,unsigned int)),this,SLOT(transUpdate(int,unsigned int)));
    connect(this,SIGNAL(show_update(int,QString)),this,SLOT(showUpdate(int,QString)));

    cout<<"carnumber="<<carnumber<<endl;
    cout<<"x="<<car_x<<endl;
    cout<<"y="<<car_y<<endl;
    cout<<"width="<<car_width<<endl;
    cout<<"height="<<car_height<<endl;
}
Car::Car()
{

}
Car::~Car()
{

}
void Car::sleep(int t)
{
    QTime newTime = QTime::currentTime().addMSecs(t);
    while(QTime::currentTime() < newTime)
    QCoreApplication::processEvents(QEventLoop::AllEvents,100);
}

void Car::setCarInfo(QString license, QString money, QString model)
{
    carlicense = license;
    carmoney=  money;
    carmodel= model;

}

QString Car:: getCarlicense()
{
    return carlicense;

}
QString Car:: getCarmodel()
{
    return carmodel;

}
QString Car:: getCarmoney()
{
    return carmoney;

}




//检测入口栅栏何时打开
void Car::FencesPower(int flag)
{
    int fences_x;
    if(flag==3) fences_x=fencesExit_x;
    if(flag==1) fences_x = fencesEnter_x;

if(carnumber==1){
  for( int i=car_x; i-car_width<fences_x-CHECK_LENGTH; ++i)
    {
       emit update(carnumber,i,car_y,car_width,car_height);
       sleep(12);
       car_x=i;
    }}

if(carnumber==2){
     for( int i=car_x; i-car_width>fences_x-CHECK_LENGTH; --i)
    {
       emit update(carnumber,i,car_y,car_width,car_height);
       sleep(12);
       car_x=i;
    }

}

if(carnumber==3){
  for( int i=car_x; i<400; ++i)
    {
       emit update(carnumber,i,car_y,car_width,car_height);
       sleep(12);
       car_x=i;
    }
  int i;
  while(isRun){
  if(carnumber==3){
      for( int i=car_x; i<400; ++i)
        {
           emit update(carnumber,i,car_y,car_width,car_height);
           sleep(12);
           car_x=i;
        }

      if(eastflag==1)
      {
       for(i=car_x;i<1500;++i)
          {
          emit update(carnumber ,i,car_y,car_width,car_height);
          sleep(12);
          }

           car_x=i;
      }

      if(eastflag==0   &&   car_x >=670)
      {

          for(i=car_x;i<1000;++i)
             {
             emit update(carnumber,i,car_y,car_width,car_height);
             sleep(12);
             }

         car_x=i;

      }

      if(car_x>=1000)
      {
         car_x=0;

          emit update(carnumber,car_x,car_y,car_width,car_height);


      }}

    }

  }
    if(flag==1){
        emit trans_update(carnumber,90);
    // emit update(carnumber,car_x,car_y,car_height,car_width);
     int tem=car_height;
     car_height = car_width;
     car_width = tem;
    }
    int fences_y ;
    if(flag==1)fences_y = fencesEnter_y;
    if(flag==3)fences_y = fencesExit_y;

    int car_h = car_height;

    for( int i=car_y; i+car_h<fences_y-CHECK_LENGTH; ++i)
    {

       emit update(carnumber,car_x,i,car_width,car_height);
       sleep(10);
       car_y=i;
    }

    emit Fence_Update(flag);



}
//转弯
void Car::wheel()
{
    if(car_x > park_x)
    {
        emit trans_update(carnumber,90);
        int tem=car_height;
        car_height = car_width;
        car_width = tem;
        for(int i=car_x; i>park_x-INSTANCE; --i)
        {
           emit update(carnumber,i,car_y,car_width,car_height);
           car_x=i;
            sleep(10);
        }

    }else
    {
        emit trans_update(carnumber,270);

       // emit update(carnumber,car_x,car_y,car_height,car_width);
        int tem=car_height;
        car_height = car_width;
        car_width = tem;
        for(int i=car_x; i<park_x-INSTANCE; ++i)
        {   car_x=i;
            emit update(carnumber,i,car_y,car_width,car_height);
            sleep(10);
        }

     }
}
void Car::stop(){

     emit update(carnumber,car_x,car_y,car_width,car_height);
     sleep(10);

}
//停车
void Car::stopPark()
{
    if(car_y > park_y)
    {
        emit trans_update(carnumber,270);

       // emit update(carnumber,car_x,car_y,car_height,car_width);
        int tem=car_height;
        car_height = car_width;
        car_width = tem;

        for(int i=car_y; i>park_y+CHECK_LENGTH; --i)
        {car_y=i;
           emit update(carnumber,car_x,i,car_width,car_height);
            sleep(10);
        }

    }else
    {
        emit trans_update(carnumber,90);

       // emit update(carnumber,car_x,car_y,car_height,car_width);
        int tem=car_height;
        car_height = car_width;
        car_width = tem;
        for(int i=car_y; i<park_y-CHECK_LENGTH; ++i)
        { car_y=i;
           emit update(carnumber,car_x,i,car_width,car_height);
            sleep(10);
        }

    }
}
//红外扫描车的信息
void Car::scanCar(int flag)
{   int scan_y;
    if(flag==1)scan_y= scanBtn_y;
    if(flag==3)scan_y = scanBtnExit_y;
    if(car_y == scan_y)
    {
        QString carInfo =getCarlicense()+" "+getCarmoney()+" "+getCarmodel();
        emit show_update(flag,carInfo);
    }

}
//红外检测入口栅栏何时关闭
void Car::redEnterCheck(int flag)
{
    if(flag==2 && car_y == enterRed_y)emit Fence_Update(flag);
    if(flag==4 && car_y == ExitRed_y) emit Fence_Update(flag);
}
void Car::cheatPark()
{
   wheel();
   stopPark();
}
void Car::stopCarTime(unsigned int msec)
{
    sleep(msec);
}

void Car::run()

{
    FencesPower(1);
    if(carnumber==1){
    for(int i=car_y; i+car_height<downStreet_y; ++i)
    {
        emit update(carnumber,car_x,i,car_width,car_height);
        car_y=i;
        scanCar(1);
        redEnterCheck(2);
        sleep(10);
    }
    cheatPark();            //诱导停车
     cout<<"cheatPark()"<<endl;
     stopCarTime(1000); //停车时间    sleep(1000);
        exitPark();
     walkExit();
     int i;
     for(  i=car_x; i<400; ++i)
       {
          emit update(carnumber,i,car_y,car_width,car_height);
          sleep(12);
          car_x=i;
       }
     if(eastflag==1)
     {
      for(i=position_x;i<1500;++i)
         {
         emit update(carnumber ,i,car_y,car_width,car_height);
         sleep(12);
         }

          car_x=i;
     }

     if(eastflag==0   &&   car_x >=670)
     {

         for(i=car_x;i<1500;++i)
            {
            emit update(carnumber,i,car_y,car_width,car_height);
            sleep(12);
            }

        car_x=i;

     }

     if(car_x>=1500)
     {
        car_x=0;

         emit update(carnumber,car_x,car_y,car_width,car_height);


     }}



    if(carnumber==2){
    for(int i=car_y; i+car_height<downStreet_y; ++i)
    {
        emit update(carnumber,car_x,i,car_width,car_height);
        car_y=i;
        scanCar(1);

        redEnterCheck(2);

        sleep(12);
}
    cheatPark();            //诱导停车
     cout<<"cheatPark()"<<endl;
     stopCarTime(200); //停车时间    sleep(1000);
        exitPark();
       walkExit();
    }
int i;
while(isRun){
if(carnumber==3){
    for( int i=car_x; i<400; ++i)
      {
         emit update(carnumber,i,car_y,car_width,car_height);
         sleep(12);
         car_x=i;
      }

    if(eastflag==1)
    {
     for(i=position_x;i<1500;++i)
        {
        emit update(carnumber ,i,car_y,car_width,car_height);
        sleep(12);
        }

         car_x=i;
    }

    if(eastflag==0   &&   car_x >=670)
    {

        for(i=car_x;i<1500;++i)
           {
           emit update(carnumber,i,car_y,car_width,car_height);
           sleep(12);
           }

       car_x=i;

    }

    if(car_x>=1500)
    {
       car_x=0;

        emit update(carnumber,car_x,car_y,car_width,car_height);


    }}

  }
}





/**********************************************************************/
//驶出停车场
void Car::exitPark()
{
    if(car_y < midLine_y)//说明在上部分停车
    {


        for(int i=car_y; i<midLine_y; ++i)
        {
            emit update(carnumber,car_x,i,car_width,car_height);
            car_y=i;
            sleep(10);
        }

     }
     else   //下半部停车
     {

        for(int i=car_y; i-INSTANCE>midLine_y; --i)
        {   car_y=i;
            emit update(carnumber,car_x,i,car_width,car_height);
            sleep(10);
        }

     }
    walkFangxiangToExit();

}
void Car::walkExit()
{

    if(dir==left)emit trans_update(carnumber,90);
    if(dir == right)emit trans_update(carnumber,270);

   // emit update(carnumber,car_x,car_y,car_height,car_width);
    int tem=car_height;
    car_height = car_width;
    car_width = tem;

    for(int i= car_y;i< scanBtnExit_y+CHECK_LENGTH;++i)
    {
        car_y=i;
        scanCar(3);
        cout<<"car_y="<<car_y<<endl;
        emit update(carnumber,car_x,i,car_width,car_height);
        sleep(10);
   }
    FencesPower(3);

    for( int i=car_y; i+car_height<ExitRed_y+CHECK_LENGTH; ++i)
    {
       car_y=i;
       redEnterCheck(4);
       emit update(carnumber,car_x,i,car_width,car_height);
       sleep(10);

    }

    //go ahead to the downline
    for(int i = car_y;i+INSTANCE+car_height<downline_y;++i)
    {
        car_y=i;
        emit update(carnumber,car_x,i,car_width,car_height);
            sleep(10);
    }
    //trans 90
    emit trans_update(carnumber,90);

    //emit update(carnumber,car_x,car_y,car_height,car_width);
       tem=car_height;
    car_height = car_width;
    car_width = tem;
    //go ahead to the leftline
    for(int i = car_x;i-INSTANCE>leftline_x;--i)
    {
        car_x=i;
        emit update(carnumber,i,car_y,car_width,car_height);
            sleep(10);
    }
    emit trans_update(carnumber,90);

    //emit update(carnumber,car_x,car_y,car_height,car_width);
      tem=car_height;
    car_height = car_width;
    car_width = tem;

    //go ahead to the init_car_y
    for(int i = car_y;i-INSTANCE>init_car_y;--i)
    {
        car_y=i;
        emit update(carnumber,car_x,i,car_width,car_height);
            sleep(10);
    }

    emit trans_update(carnumber,90);

    //emit update(carnumber,car_x,car_y,car_height,car_width);
     tem=car_height;
    car_height = car_width;
    car_width = tem;

    //go ahead to the init_car_x
    for(int i = car_x;i+car_height<init_car_x;++i)
    {
        car_x=i;
        emit update(carnumber,i,car_y,car_width,car_height);
        sleep(10);
    }

cout<<"init_car_x="<<init_car_x<<" init_car_y="<<init_car_y<<endl;
cout<<"car_x="<<car_x<<" car_y="<<car_y<<endl;
stop();
}

void Car::walkFangxiangToExit()
{
    //从右边走向出口


    if(car_x > flagLineFive_x)
    {
        emit trans_update(carnumber,270);
        dir=right;
        //emit update(carnumber,car_x,car_y,car_height,car_width);
        int tem=car_height;
        car_height = car_width;
        car_width = tem;

        for(int i=car_x; i-INSTANCE > flagLineFive_x; --i)
        { car_x=i;
            emit update(carnumber,i,car_y,car_width,car_height);
                sleep(10);
        }

    }else   //从左边走向出口
    {
        dir = left;
      if(car_y>midLine_y)  emit trans_update(carnumber,90);//下半部分停车
      else  emit trans_update(carnumber,270);
      //  emit update(carnumber,car_x,car_y,car_height,car_width);
        int tem=car_height;
        car_height = car_width;
        car_width = tem;

        for(int i=car_x; i+INSTANCE < flagLineFive_x; ++i)
        { car_x=i;
           emit update(carnumber,i,car_y,car_width,car_height);
           sleep(10);
        }

    }
}





//********************************************************************//
//*****************************************************************//
void Car::slotUpdate(int i,int x,int y, int width, int height)
{

    pMain->updateposition(i,x,y,width,height);

}

void Car::FenceUpdate(int i)
{

    if(i==1)  pMain->FencesEnterOn();
    else if(i==2)pMain->FencesEnterOff();
    else if(i==3)pMain->FencesExitOn();
    else if(i==4)pMain->FencesExitOff();
    else i=0;

}

void Car::transUpdate(int i, unsigned int angle)
{

    pMain->trans(i,angle);

}
void Car::showUpdate(int i, QString carInfo)
{

    if(i==1){

        string str =pMain->showToEnter(carInfo);
        int idx = str.find(" ");
        if(idx != -1)
     {
        park_x = atoi( str.substr(0,idx).c_str());
        park_y = atoi( str.substr(idx+1,str.length()).c_str());

    }



}

     if(i==3)  pMain->showToExit(carInfo);
}

2.mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "car.h"



int isRun;
int westflag;
int eastflag;

Car * thread1,*thread2,*thread3;

//车位y坐标
void MainWindow::initCarPort()
{
    maplive.insert(pair<string,int>("A1",0));
    maplive.insert(pair<string,int>("A2",1));
    maplive.insert(pair<string,int>("A3",1));
    maplive.insert(pair<string,int>("A4",0));
    maplive.insert(pair<string,int>("A5",0));
    maplive.insert(pair<string,int>("A6",0));
    maplive.insert(pair<string,int>("A7",0));
    maplive.insert(pair<string,int>("A8",0));
    maplive.insert(pair<string,int>("A9",0));
    maplive.insert(pair<string,int>("A10",0));
    maplive.insert(pair<string,int>("A11",0));
}


MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    initCarPort();
    ui->setupUi(this);
    timer2 =new QTimer(this);
    carx=ui->car->x();
    carx2=ui->car3->x();
    timer1=new QTimer(this);
    QString str= "car: autoxi\r\nmoney: 300$\r\nNumber: ERO678";

    position_x = ui->car->x();
    position_y = ui->car->y();
    position_weight = ui->car->width();
    position_height = ui->car->height();

    position_x1 = ui->car2->x();
    position_y1 = ui->car2->y();
    position_weight1 = ui->car2->width();
    position_height1 = ui->car2->height();
    position_x2 = ui->car3->x();
    position_y2 = ui->car3->y();
    position_weight2 = ui->car3->width();
    position_height2 = ui->car3->height();

}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::mysleep(unsigned int msec)
{
    QTime newTime = QTime::currentTime().addMSecs(msec);
    while(QTime::currentTime() < newTime)
        QCoreApplication::processEvents(QEventLoop::AllEvents,100);

}

//将小车信息写入文件
void MainWindow::writeTofile(QString carInfo)
{
    QFile f("F:\\text.txt");
    if(!f.open(QIODevice::WriteOnly|QIODevice::Append))
    {
        qDebug()<<"Open failed.";
    }else
    {
        QTextStream txtOutput(&f);
        txtOutput<<carInfo<<endl;
    }
    f.close();
}


/*
读文件操作
void MainWindow::readFromFile()
{
    QFile f("F:\\text.txt");
    if(!f.open(QIODevice::ReadOnly|QIODevice::Text))
    {
        qDebug()<<"Open failed.";
    }else
    {
        QTextStream txtInput(&f);
        QString lineStr;
        while(!txtInput.atEnd())
        {
            lineStr = txtInput.readLine();
            qDebug()<<lineStr;
        }
    }
    f.close();
}
*/

//判断从数据库中获取到的车位判断是否被占用
/*int MainWindow::judgeIsNullOfCar(QString linestr)
{
    string s = linestr.toStdString();
    int flagCar = s[s.length()-1]-'0';
    if(0 == flagCar) return 1;  //说明此车位未被占用
    else return -1;             //说明此车位已被占用
}
//返回从数据库中获取到的车位信息
QString MainWindow::readFromFile(QString path)
{
    QFile f(path);
    QString str = "fill";
    if(!f.open(QIODevice::ReadOnly|QIODevice::Text))
        qDebug()<<"Open failed.";
    else
    {
        QTextStream txtInput(&f);
        QString lineStr;
        while(!txtInput.atEnd())
        {
            lineStr = txtInput.readLine();
            if( judgeIsNullOfCar(lineStr) == 1 )
            {
                f.close();
                str = lineStr;
                break;
            }
        }
    }
    f.close();
    return str;
}*/


//切割小车信息
void MainWindow::splitCarInfor(QString carInfo,vector<string>& v)
{
     string str = carInfo.toStdString();
     while(1)
     {
         int idx = str.find(" ");
         if(idx==-1)
         {
             break;
         }
         string s = str.substr(0,idx);
         v.push_back(s);
         str = str.substr(idx+1,str.length());
     }
}

//切割车位信息
/*void MainWindow::splitCarPort(string& str)
{
    vector<string> v;
    while(1)
    {
        int idx = str.find(" ");
        if(idx==-1)
        {
            break;
        }
        string s = str.substr(0,idx);
        v.push_back(s);
        str = str.substr(idx+1,str.length());
    }
    mCarPort = v[0];
    mx = atoi(v[1].c_str());
    my = atoi(v[2].c_str());
}
//读小车车位信息
string MainWindow::readSqlCar()
{

    QString result = readFromFile("F:\\data.txt");
    return result.toStdString();
}*/


//返回true说明匹配成功
bool MainWindow::isPort(string lineStr)
{
    int len = mCarPort.length();
    int res = -1;
    cout<<"macr:"<<mCarPort<<endl;
    cout<<"str:"<<lineStr<<endl;
    res = lineStr.compare(0,len,mCarPort,0,len);//返回0车位匹配，否则不匹配
    if(res == 0)return true;
    return  false;
}
void MainWindow::getSysTime()
{
    QDateTime local(QDateTime::currentDateTime());
    mLocalTime = local.toString().toStdString();


   /* QDate d = local.date();

    cout<<d.year()<<endl;
    cout<<d.month()<<endl;
    cout<<d.day()<<endl;

    QTime t = local.time();
    cout<<t.hour()<<endl;
    cout<<t.minute()<<endl;
    cout<<t.second()<<endl;*/
}

//设置xy坐标
string MainWindow::getXY(string lineStr)
{
    string str = "";
    string s;
    //cout<<"lineStr:"<<lineStr<<endl;
    int index = lineStr.find(" ");
    if(index != -1)
    {
        str = lineStr.substr(index+1,lineStr.length());

    }
    return str;
//    int idx = str.find(" ");
//    if(idx != -1)
//    {
//      park.mx = atoi( str.substr(0,idx).c_str() );
//      park.my = atoi( str.substr(idx+1,str.length()).c_str() );
//    }
}
//从文件中读取对应车位的位置
string MainWindow::readPositionFromFile(QString path)
{
    QFile f(path);
    string pos_str="";
    bool res = false;
    if(!f.open(QIODevice::ReadOnly|QIODevice::Text))
        qDebug()<<"Open failed.";
    else
    {
        QTextStream txtInput(&f);
        QString lineStr;
        while(!txtInput.atEnd())
        {
            lineStr = txtInput.readLine();
            //cout<<"lineStr:"<<lineStr.toStdString()<<endl;
            res = isPort(lineStr.toStdString());//对比车位是否一致
            //cout<<"res"<<res<<endl;
            if(res)
            {
                pos_str = getXY(lineStr.toStdString());//提取并设置xy
                break;
            }
        }
    }
    f.close();
    return pos_str;
}
//判断map中小车的标志位是否被占用，并设置mCarPort满返回fill
string MainWindow::judgeCarPortFlag()
{
    map<string,int>::iterator ite;
    string res = "fill";
    for(ite = maplive.begin();ite != maplive.end();++ite)
    {
        if(ite->second == 0)
        {
            ite->second = 1;
            mCarPort = ite->first;
            return ite->first;
        }
    }
    return res;
}

string MainWindow::setWork()
{
    string res = judgeCarPortFlag();

    if(res.compare("fill") == 0)return res;

     string pos = readPositionFromFile("data.txt");

        return pos;

}

//入口显示，分配停车位,未满则显示车位，满了则无法停车。。。。
string MainWindow::showToEnter(QString carInfo)
{
    vector<string> carSpliteInfo;  //小车的信息划分存储
    splitCarInfor(carInfo,carSpliteInfo);
    getSysTime();
    vector<string> v;
    v.push_back("card:");
    v.push_back("money:");
    v.push_back("carPort:");
    v.push_back("time:");
    string s;                        //
    string sub;
    string str = setWork();  //失败返回fill,成功返回车位

    if(str.compare("fill") == 0) carSpliteInfo.push_back("fill");
    else
    {
       //splitCarPort(str);

       carSpliteInfo.push_back(mCarPort);      //将划分得到的车位加入
       carSpliteInfo.push_back(mLocalTime);
    }

    for(int i=0;i<carSpliteInfo.size();++i)
    {
        cout<<carSpliteInfo[i]<<"   ";
        sub = v[i]+carSpliteInfo[i]+'\n';
        s += sub;
    }
    ui->enterShowLabel->setText(s.c_str());
    return str;
}


//入口显示，分配停车位,未满则显示车位，满了则无法停车。。。。
void MainWindow::showToExit(QString carInfo)
{

    vector<string> carSpliteInfo;  //小车的信息划分存储
    splitCarInfor(carInfo,carSpliteInfo);
    getSysTime();
    vector<string> v;
    v.push_back("车牌:");
    v.push_back("money:");
    v.push_back("brand:");
    v.push_back("carPort:");
    v.push_back("time:");
    string s;                        //
    string sub;

    {
       //splitCarPort(str);

       carSpliteInfo.push_back(mCarPort);      //将划分得到的车位加入
       carSpliteInfo.push_back(mLocalTime);
    }

    for(int i=0;i<carSpliteInfo.size();++i)
    {
        cout<<carSpliteInfo[i]<<"   ";
        sub = v[i]+carSpliteInfo[i]+'\n';
        s += sub;
        cout<<"s==="<<s<<endl;
    }
    ui->exitShowLable->setText(s.c_str());
}





//红外检测入口栅栏打开
void MainWindow::FencesEnterOn()
{
    int distanceInEnterDoor = ui->enterDoorTwo->x()-ui->enterDoorOne->x();

    ui->fencesEnter->setGeometry(ui->fencesEnter->x(),
                            ui->fencesEnter->y(),
                            ui->fencesEnter->width()-distanceInEnterDoor,
                            ui->fencesEnter->height());
}

//红外检测入口栅栏关闭
void MainWindow::FencesEnterOff()
{
    int distanceInEnterDoor = ui->enterDoorTwo->x()-ui->enterDoorOne->x();

    ui->fencesEnter->setGeometry(ui->fencesEnter->x(),
                            ui->fencesEnter->y(),
                            ui->fencesEnter->width()+distanceInEnterDoor,
                            ui->fencesEnter->height());
}

//红外检测出口栅栏打开
void MainWindow::FencesExitOn()
{
    int distanceInExitDoor = ui->exitDoorTwo->x()-ui->exitDoorOne->x();

    ui->fencesExit->setGeometry(ui->fencesExit->x(),
                             ui->fencesExit->y(),
                             ui->fencesExit->width()-distanceInExitDoor,
                             ui->fencesExit->height());
}
//红外检测出口栅栏关闭
void MainWindow::FencesExitOff()
{
    int distanceInExitDoor = ui->exitDoorTwo->x()-ui->exitDoorOne->x();

    ui->fencesExit->setGeometry(ui->fencesExit->x(),
                             ui->fencesExit->y(),
                             ui->fencesExit->width()+distanceInExitDoor,
                             ui->fencesExit->height());

}






/*void MainWindow::setParkFlag()
{
    maplive.find(mCarPort);
    //fstream file("test.txt",ios::in|ios::out);
    string buff;
    ifstream infile;//=new ifstream(file);
    infile.open("F:\\data.txt",ios::in|ios::out);
    int offset=0;
    int index=-1;
    int count=0;
    while(getline(infile,buff))
    {
        cout<<"count:"<<count<<endl;
        index=buff.find_first_of(" ",offset);

            string str=buff.substr(offset,index-offset);
            count+=buff.length()+1;
            cout<<"length :"<<buff.length();
            cout<<"str:"<<str<<endl;
            if(str==mCarPort)
            {
                //count-=1;
                cout<<"count:"<<count<<endl;
                writeDataFile(count);//she zhi sign;
                break;
            }
    }
}*/

//*********************************************************
//********************************************************

void MainWindow::trans(int i,unsigned int angle)
{
    if(i==2){
QPixmap pixmap1(":/new/prefix1/picture/picture/bus.jpg");
matrix1.rotate(angle);
ui->car2->setPixmap(pixmap1.transformed(matrix1,Qt::SmoothTransformation));
ui->car2->setGeometry(ui->car2->x(),ui->car2->y(),ui->car2->height(),ui->car2->width());}
    if(i==1){
QPixmap pixmap(":/new/prefix1/picture/picture/you.png");
matrix.rotate(angle);
ui->car->setPixmap(pixmap.transformed(matrix,Qt::SmoothTransformation));
ui->car->setGeometry(ui->car->x(),ui->car->y(),ui->car->height(),ui->car->width());}
    if(i==3){
QPixmap pixmap3(":/new/prefix1/picture/picture/you.png");
matrix3.rotate(angle);
ui->car3->setPixmap(pixmap3.transformed(matrix3,Qt::SmoothTransformation));
ui->car3->setGeometry(ui->car3->x(),ui->car3->y(),ui->car3->height(),ui->car3->width());}


}

void MainWindow::run()
{
    // getSysTime();
     thread1=new Car(this,1,position_x,position_y,position_weight,position_height);

      setCarInfo(1);
     thread1->start();
     thread2=new Car(this,2,position_x1,position_y1,position_weight1,position_height1);
      setCarInfo(2);
     thread2->start();
     thread3=new Car(this,3,position_x2,position_y2,position_weight2,position_height2);
     thread3->start();


}
void MainWindow::setCarInfo(int num)
 {
   if(num==1)thread1->setCarInfo("陕A14785","50","奥迪");
   if(num==2)thread2->setCarInfo("陕A25896","100","宾利");


}


void MainWindow::updateposition(int i,int x,int y,int width, int height)
{
  if(i==1)  ui->car->setGeometry(x,y,width,height);
  if(i==2)  ui->car2->setGeometry(x,y,width,height);
  if(i==3)  ui->car3->setGeometry(x,y,width,height);

}





void MainWindow::on_pushButton_clicked()
{
    QPixmap pixmap(":/new/prefix1/picture/picture/you.png");
    ui->car->setPixmap(pixmap);
    QPixmap pixmap1(":/new/prefix1/picture/picture/bus.jpg");
    ui->car2->setPixmap(pixmap1);

    QPixmap pixmap3(":/new/prefix1/picture/picture/you.png");
    ui->car3->setPixmap(pixmap3);
    run();
    wheel();
    settimer1 = 14;
    settimer2 = -1;
    ui->lcdNumber->setDigitCount(2);
    ui->lcdNumber->setMode(QLCDNumber::Dec);
    ui->lcdNumber->setSegmentStyle(QLCDNumber::Filled);
    ui->lcdNumber->display(settimer1);
    ui->lcdNumber_2->setDigitCount(2);
    ui->lcdNumber_2->setMode(QLCDNumber::Dec);
    ui->lcdNumber_2->setSegmentStyle(QLCDNumber::Filled);
    ui->lcdNumber_2->display(settimer1);
    westflag=0;
    eastflag=0;
    timer = new QTimer();
    timer->setInterval(1000);
    timer->start();
    isRun=1;
    connect(timer,SIGNAL(timeout()),this, SLOT(onTimerOut()));
    timer2->start(5);
    timer1->start(5);


}


void MainWindow::updatelight()
{

    settimer2=14;
    settimer1=-1;
    ui->lcdNumber->display(settimer2);
    ui->lcdNumber_2->display(settimer2);
    westflag=0;
    eastflag=0;



}

void MainWindow::lightOn(QLabel *label)
{
    QImage image(":/new/prefix1/picture/picture/liang.jpg");
    label->setPixmap(QPixmap::fromImage(image));
    label->setGeometry(label->x(),label->y(),label->width(),label->height());
    label->show();

}
void MainWindow::lightOff(QLabel *label)
{
     QImage image(":/new/prefix1/picture/picture/an.jpg");
    label->setPixmap(QPixmap::fromImage(image));
    label->setGeometry(label->x(),label->y(),label->width(),label->height());
    label->show();

}


void MainWindow::onTimerOut()
{

    if(settimer2>0)
 {

             eastflag=0;
             westflag=0;
             settimer2--;

     ui->red->show();
     ui->yellow->hide();
     ui->green->hide();
     ui->lcdNumber->display(settimer2);


     ui->red_2->show();
     ui->yellow_2->hide();
     ui->green_2->hide();
     ui->lcdNumber_2->display(settimer2);
 }

  if(settimer2==0)
  {

   eastflag=0;
   westflag=0;

      ui->yellow->show();
      ui->red->hide();
      ui->yellow_2->show();
      ui->red_2->hide();

      mysleep(1000);

      ui->green->show();
      ui->yellow->hide();

      ui->green_2->show();
      ui->yellow_2->hide();

      settimer1 = 14;
      settimer2=-1;

      ui->lcdNumber->display(settimer1);
       ui->lcdNumber_2->display(settimer1);

  }

    if(settimer1>0)
    {

        eastflag=1;
        westflag=1;

        settimer1--;


        //east
                ui->red->hide();
                ui->yellow->hide();
                ui->green->show();
                ui->lcdNumber->display(settimer1);

                ui->red_2->hide();
                ui->yellow_2->hide();
                ui->green_2->show();
                ui->lcdNumber_2->display(settimer1);

    }

   if(settimer1==0)
    {

        eastflag=0;
        westflag=0;

         ui->yellow->show();
         ui->green->hide();

         ui->yellow_2->show();
         ui->green_2->hide();

         mysleep(1000);


         ui->red->show();
         ui->yellow->hide();
         ui->red_2->show();
         ui->yellow_2->hide();
         settimer2 = 14;
         settimer1=-1;
         ui->lcdNumber->display(settimer2);
         ui->lcdNumber_2->display(settimer2);


     }


}

三、运行结果

 

 

 

学习好难真的好难
关注
  • 0
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
QT小车上位机程序
04-06
QT小车上位机程序 可以显示视频，定位，姿态显示等
智能小车QT远程客户端
01-13
基于QT的客户端，实现对自动导引车的远程监控，有三个线程，主线程实现图像显示，socket线程实现通信，control线程实现对小车的控制。
智能小车代码.zip
03-13
这个代码是完整的并发进程的基于stm32的智能小车代码，里面包含的有服务器和客户端，服务器使用的是c，客户端时Qt
qt+ubuntu+路由模块+stm32f1 实训做智能小车项目的笔记.docx
01-08
在虚拟机下的ubuntu系统的qt界面配置一个tcp客户端,发送指令去给小车的路由模块的两个服务器使其通过串口来连接stm32f1控制小车前进后退左转右转
Pthon+Qt 智能小车
09-05
Pthon+Qt 智能小车
QT+树莓派+STM32 搭建远程监控小车
04-29
资源主要实现了一个基于树莓派和Qt上位机的远程监控小车。可以通过自制的遥控器和QT上位机实现两种控制方式，Qt上位机可以实时查看小坦克上的摄像头拍摄的画面。
基于bearpi的智能小车--Qt上位机设计
君莫笑的博客
03-17 1535
实现的控制小车上位机程序用于控制自制的遥控小车，控制方式为点击窗口中的按钮实现控制或者通过键盘的方向键来控制。
STM32遥控小车上位机部分（C++环境下的Qt界面编程）
jkjijijkv的博客
09-09 8861
遥控小车上位机设计（Windows）介绍一、界面效果二、各部分的实现1. 核心部分：串口实现2. 连接组3. 控制组4. 显示组5. 设置组功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 介绍 本文实现的控制小车程序用于控制自制的
以下是一个使用c++ Qt编写的简单的遥控车控制界面的示例源代码，详细注释
loxp2018的博客
04-14 844
setWindowTitle(tr(“遥控车控制界面”));qDebug()
Qt开发-操控Web小车案例
hw5230的博客
04-17 919
上次的文章《Qt与Web混合开发》，讨论了Qt与Web混合开发相关技术。这次通过一个web控制小车的案例，继续讨论相关技术。本文会先介绍Qt与Web嵌套使用,再介绍Qt与Web分开使用，之后着重讨论分开使用的一些实现细节，特别是WebChannel通信、WebChannel在Web/typescript中的使用。
STM32智能小车
03-15
本资料可以用于许多初学者，可以很好的用于智能车测试，以及代码调试。
qt编写andriod端手机控制智能小车---蓝牙小车
hs977986979的博客
04-01 2700
最近没事，用Qt写了一个蓝牙遥控器，效果还可以，贴出来给大家看看。有需求的可以加我QQ：2284108152 现在开始介绍软件： 软件app（BlueCar）： 双击app进入蓝牙连接界面，找到蓝牙串口模块HC-06，点中双击： 等待5秒钟，然后提示连接成功连接。 点击ok，进入控制界面： 接下来单独介绍控制界面： 上面图中，左右两边红框区域是控制...
【瑞萨RA MCU创意氛围赛】基于FSP库开发 --- Qt遥控小车
Bit_Dong的博客
06-13 937
本产品启动方式为“电容按键”一键启动，用过触发电容按键初始化板载的ESP8266 WiFi模块，服务端为Qt Android开发后的app下载到安卓手机上，在打开服务器之后，WiFi模块即能成功连接并发出响应信号，同时在手机上实时显示小车状态(如直行、左转、右转、后退、左右轮相对速度等等)，可在手机上远程控制小车转向及左右轮的速度值，若匀速安全行驶的情况下，板载的LED灯显示绿色表示正常行驶，若出现速度过快或左右轮相差极大板载的LED灯显示蓝色代表警示，如在超出一定速度值，将会强制停车防止意外事故的发生。
基于Qt的wifi智能小车的制作(一)
热门推荐
1+1=10 个人博客http://kevinlq.com/
10-27 1万+
基于Qt的wifi智能小车的制作（一）         好久不写博客了，真的是有点惭愧了。翻开上一次的博客，到现在已经2个多月了，只能说是自己太懒惰了！忙是另一回事！趁今天晚上有点时间回顾下这一段时间的收获以及做的一些东西，算是一份笔记，一遍以后能回想起。 首先说说开始做的一款wifi小车吧，一方面是因为个人的爱好，一方面算是其他原因。首先上几张小车照片。
基于Qt、树莓派和STM32的智能家居应用开发
Misriter的博客
06-15 900
数据页主要是用来显示数据库信息的，左侧文本框里是数据库全部信息，拥有三种搜索方法，搜索温度、搜索湿度、搜索时间。这里为了方便开发，触屏和鼠标左键都能触发滑动，不过要判断一下，注意如果使用投屏软件操作，记得在__arm__前取反。然后创建一个QMainWindow取名SmartHome用来搭载页面，这里我搭载了1个滑动页，滑动又搭载了3个页面，分别为首页、连接页、数据页。我决定在首页实现一些简单的功能，很常见的显示日期、时间、天气，在上方我加入了网络连接检测，日后可以考虑加入别的检测。
11.如何在非固定大小的地图图片上正确渲染ROS小车的位置和运行轨迹
Master Cui的博客
11-11 615
最近需要实现一个功能：在使用cartographer建图时，需要实时显示AGV的位置，并且由用户控制是否显示AGV的运动轨迹 基本思路就是：获取里程计坐标系和车体坐标系的坐标变换，然后通过该坐标变换计算出小车相对于建图原点的位姿，该位姿包含了一组x,y的坐标，然后记录该组坐标并通过这三个坐标将该位姿转换为QT图片中的像素坐标，然后根据像素坐标使用QT进行渲染 但是遇到这样的一个问题：使用cartographer建图时，图片并不使固定大小的，而是会随着地图的增大。显示地图的图片逐渐增大的过程中，地图中的轨
qt write函数_圆曾经的小车梦，造一台智能小车(四)之QT上位机控制小车
weixin_33089349的博客
01-24 1427
接前面几篇文章：圆曾经的小车梦，造一台智能小车(一)圆曾经的小车梦，造一台智能小车(二)基于小熊派WIFI PWM控制小车前进后退圆曾经的小车梦，造一台智能小车(三)之小车前进后退左右转基本框架QT控制界面大致如下，非常简单：包含前进、后退、左转、右转4个按钮，外加一个显示如何来实现呢？很简单。一、分别拖四个QPushButton按钮过去改成自己想要表达的方式二、再拖一个textBro...
基于STM32-Socket-Qt 遥控小车(一代)
Bit_Dong的博客
11-08 2720
本项目本质为客户端与服务器之间的通信，通过发送不同的指令，服务器和客户端进行不同的操作。客户端：基于STM32制作简单行驶小车服务器：安卓手机，基于Socket编程下 用QT进行安卓开发，将app传输到手机上。TCP通信：ESP8266手机端发送不同指令，小车执行不同操作。
嵌入式树莓派智能小车 测温 qt
最新发布
09-09
对于嵌入式树莓派智能小车测温的需求，您可以使用温度传感器来获取环境温度数据，并通过嵌入式系统进行处理和显示。以下是一个基本的实现步骤： 1. 硬件准备：选择合适的温度传感器，例如DS18B20数字温度传感器。将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值