qt串口编程[转帖]

qt串口编程[转帖]

// 也不知道是用的哪个版本,拷过来只是用来做参考

[serial.cpp]
#include <qapplication.h>
#include <qmainwindow.h> 

#include "mainwindow.h"
int main(int argc, char *argv[])
{
    QApplication a(argc,argv);
  MainWindow m;
   
    a.setMainWidget(&m);
    m.show();
  return a.exec();
}


[mainwindow.h]
#ifndef MAIN_WINDOW_H
#define MAIN_WINDOW_H

#include <qmainwindow.h>

class QLabel;
class QPushButton;
class QLineEdit;
class QPixmap;
class SerialThread;

class MainWindow:public QMainWindow {
    Q_OBJECT
public:
    MainWindow(QWidget * parent = 0, const char * name= 0) ;
    ~MainWindow(){};
   
    void setCounter(int no);
    void setMsgText(char* txt);
public slots:   
    void serialOperate();
    void loadJPEGFile();
   
protected:
    void    paintEvent( QPaintEvent * );
   
private:
 
    QLineEdit *msg;
    QPushButton *btn;
    QPushButton *btn2LoadImg;
    QPixmap *pix;
    QLabel *lab;
    SerialThread *a;
    int counter;
};

#endif


[mainwindow.cpp]

#include <qlabel.h>     
#include <qpushbutton.h> 
#include <qvbox.h> 
#include <qapplication.h>
#include <qlineedit.h>
#include <qpixmap.h>
#include <qpainter.h>
#include <qimage.h>
#include <qstring.h>


#include "mainwindow.h"   
#include "serialthread.h"   

void MainWindow::paintEvent( QPaintEvent * )
{
    QPainter paint( this );
    paint.drawLine( 0,0,500,500 ); // draw line
        paint.drawPixmap(0,0,*pix);
        }

void MainWindow::loadJPEGFile(){
     
    if(!pix->load("testjpeg")){
    //if(!pix->load("circle")){
        setMsgText("Load failed");
        return;
    }
    setMsgText("Load success!");
    update();
       
}

void MainWindow::setCounter(int no){
    counter = no;
}

void MainWindow::serialOperate(){
  a = new SerialThread(this);
    a->start();
    a->wait();
}

MainWindow::MainWindow(QWidget * parent , const char * name)
    :QMainWindow(parent, name)
{
   
        counter = 0;
       
        QVBox *vbox;
        vbox = new QVBox(this);
        vbox->resize(300,150);
        //msg = new QLabel("SERIAL PROGRAMMING",vbox);
        msg = new QLineEdit("SERIAL PROGRAMMING",vbox);
        msg->resize(300,50);
       
        pix = new    QPixmap();             
       
        btn = new QPushButton(vbox);
        btn->setText("GO!");
        QApplication::connect(btn,SIGNAL(clicked()),this,SLOT(serialOperate()));
        btn2LoadImg = new QPushButton(vbox);
        btn2LoadImg->setText("LOAD");
       
        lab = new QLabel("before load jpeg",vbox);
        QApplication::connect(btn2LoadImg,SIGNAL(clicked()),this,SLOT(loadJPEGFile()));
       
        //btn->resize(100,75);
        //vbox->show();
};

void MainWindow::setMsgText(char* txt){
        QString msgs(txt);
        QString count = QString::number(counter,10);
        msgs.append(count);
        const    char *re = msgs.ascii ();         
        //strcat(msgs,);
        msg->setText(re);   
};/


[my_define.h]
#define BAUDRATE    B115200
#define BLOCK_SIZE    200   
#define DEVICE        "/dev/ttyS0"
#define WAIT_TIME    5
#define CHANGE_LINE    0x0a
#define ACK_NUM    3
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE -1
#endif



[serialthread.h]
#ifndef SERIAL_THREAD_H
#define  SERIAL_THREAD_H
#include <qthread.h>

class MainWindow;

class SerialThread: public QThread {
public:
    SerialThread(MainWindow *parent);
    virtual void run();
private:
    MainWindow *parent;

};
#endif



[serialthread.cpp]

#include <sys/types.h>     
#include <sys/stat.h>     
#include <fcntl.h>     
#include <termios.h>     
#include <stdio.h> 

#include "my_define.h"
#include "serialthread.h"
#include "mainwindow.h"



int set_nc_mode(int fd)
{
    struct termios options;
    if  ( tcgetattr( fd,&options)  !=  0){
          perror("SetupSerial 1");
          return(FALSE);
      } /* get current port settings */

    bzero(&options, sizeof(options)); 
    options.c_cflag |= BAUDRATE | CS8 | CLOCAL | CREAD; 
    options.c_cflag &= ~CRTSCTS;
    options.c_iflag = IGNPAR; 
    options.c_oflag &=~OPOST;           
        //
      options.c_lflag = 0;           
        options.c_cc[VTIME] = WAIT_TIME;
    options.c_cc[VMIN] = BLOCK_SIZE;    /* blocking read until 5 chars received */
   
    tcflush(fd, TCIFLUSH); 
    tcsetattr(fd,TCSANOW,&options);
    return(TRUE);
}

int set_c_mode(int fd)
{
    struct termios options;
    if  ( tcgetattr( fd,&options)  !=  0){
          perror("SetupSerial 1");
          return(FALSE);
      }
    bzero(&options, sizeof(options));
    tcflush(fd, TCIOFLUSH);
    cfsetispeed(&options, BAUDRATE);
        cfsetospeed(&options, BAUDRATE);

    options.c_cflag |=(CLOCAL|CREAD);

    options.c_cflag &= ~CRTSCTS;

    options.c_cflag &= ~CSIZE;
    options.c_cflag |= CS8;

    options.c_cflag &= ~PARENB;  /* Clear parity enable,clear control mode flag */
    options.c_iflag &= ~INPCK;    /* Disable parity checking ,*/
    options.c_cflag &= ~CSTOPB;

    options.c_iflag |= IGNBRK;

    options.c_lflag |= ICANON;       
    options.c_lflag &= ~(ECHO | ECHOE | ISIG);
    options.c_oflag &= ~(OPOST);

    tcflush(fd, TCIOFLUSH);
      if (tcsetattr(fd,TCSANOW,&options) != 0){
          perror("SetupSerial 3");
        return (FALSE);
    }
    return(TRUE);
}
void send_ack(int fd)
{
    char buf[]={'A','C','K',CHANGE_LINE};
    write(fd,buf,sizeof(buf));
}
void resend(int fd)
{
    char buf[]={'R','S','D',CHANGE_LINE};
    write(fd,buf,sizeof(buf));
}
void delay(int i)
{
    int j;
    for (;i>0;i--)
        for(j=0;j<65535;j++);
}




SerialThread::SerialThread(MainWindow *parent){
    this->parent = parent;
}


void SerialThread::run()
{
    int fd,c, res;   
    int block_num,last_block;
    int i;   
    char buf[BLOCK_SIZE];             
    char file_name[32];
    FILE *fp;
    struct termios oldtio;

    block_num=last_block=0;
    fd = open(DEVICE, O_RDWR | O_NOCTTY ); 
   
    parent->setCounter(fd);
    parent->setMsgText("opend device fd::::::");   
   
   
    if (fd <0){
        perror(DEVICE); 
        parent->setMsgText("open device failed");   
    //    exit(-1); 
    }   
 
    tcgetattr(fd,&oldtio);
    set_nc_mode(fd);
    printf("Changed to nc mode/n");
    /*
    res=read(fd,( char *)file_name,32);
    parent->setCounter(res);
    parent->setMsgText("res is ::::::");   
    */

/*
   

    if(res>0){
        file_name[res-1]='/0';
        printf("Received the file name:%s/n",file_name);
        }
    else
        printf("The received file name is error./n");

    fp=fopen(file_name,"wb");
    if(fp==NULL){
        printf("Can not creat file %s!/n",file_name);
        return;
    //    exit(-1);
        }
    else
        {
            send_ack(fd);
            printf("The file %s is created./nWaitting for the block num and last block size/n",file_name);
        }

    //set_nc_mode(fd);
    //printf("Changed to nc mode/n");

    res=read(fd,buf,4);
    printf("res=%d/n",res);
    printf("Received the block num /n");

    for(i=0,block_num=0;i<4;i++){
        block_num=block_num*10+buf;
        printf("buf[%d]=%x/n",i,buf);
        }
    printf("The number of blocks is %d/n",block_num);
    send_ack(fd);

    res=read(fd,buf,3);
    printf("res=%d/n",res);
    printf("Received the last block size /n");
        for(i=0,last_block=0;i<3;i++){
                last_block=last_block*10+buf;
        printf("buf[%d]=%x/n",i,buf);
        }   
    printf("The last block size is %d/n",last_block);
    send_ack(fd);   

    printf("Starting receive blocks/n");

    for(i=0;i<block_num;i++){
        res=read(fd,buf,BLOCK_SIZE);
        if(res!=BLOCK_SIZE){
                        printf("res=%d,/t Request resend the %d block/n",res,i);
            i--;
                tcflush(fd, TCIOFLUSH);
            resend(fd);
            }
        else{           
            fwrite(buf,1,BLOCK_SIZE,fp);
            printf("Received the %d block,    res=%d/n",i,res);
            printf("Send ack signal complete,waiting to read/n");
            send_ack(fd);
            }
    }
    printf("start transporting the last block/n");

    if(last_block>0){
        send_ack(fd);
        res=read(fd,buf,last_block);
        printf("res=%d/n",res);
                if(res!=last_block){
            printf("Request resend the last block/n");
            tcflush(fd, TCIOFLUSH);
                        resend(fd);
                        }
        else
            fwrite(buf,1,last_block,fp);
        }
    send_ack(fd);
    printf("The file transports end/n");

    fclose(fp);
    printf("close the file/n");
    tcsetattr(fd,TCSANOW,&oldtio);
    close(fd);
    printf("close the serial port/n");
    */