void TextConsumer::run()
{
    int i = 0;
    // QSemaphore::availableData():
    // returns the number of available semaphores
    while( atEnd.available() || availableData.available() )
    {
        availableData.acquire();
        qDebug() << buffer[ i ];
        i = (i+1) % bufferSize;
        freeSpace.release();
    }
}
Пример #2
0
void NodeProtocolObjectPrivate::init()
{
    nodeNum = 0;
    ctlCode = 0;
    cmdType = 0;
    cmdNum = 0;
    cmdContent = 0;
    cmdPramLen = 0;
    memset(cmdParam, 0, sizeof(cmdParam));
    if(sem.available() > 0)
    {
        sem.acquire(1);
    }
}
void RadioSendThread::run()
{

    RadioServer Server;
    if (!Server.Open())
    {
        printf("Server Open failed!\r\n");
        return;
    }

    int size;
    while (true)
    {

        qDebug() << "Available: " << RadioSendRequest.available();
        RadioSendRequest.acquire();
        if (shutdownView)break;
        RadioSendMutex.lock();
        RadioCmds.set_time_stamp(0);
        size= RadioCmds.cmds_size();
        qDebug() << "size:" << size;
        qDebug() << "IsInitialized: " << RadioCmds.IsInitialized();

        if (RadioCmds.IsInitialized() && size>0 && size<10)
        {

            RadioCmds.set_time_stamp(0);
            Server.Send(RadioCmds);
            qDebug() << "sending";
        }
        else
        {
            printf("Radio Send Packet Error!\r\n");
        }

        Server.Send(RadioCmds);

        RadioCmds.clear_cmds();
        RadioSendMutex.unlock();
        RadioSendRequest.release();
    }
}
Пример #4
0
void SqlwriteThread_buffer::run()
{
    QString databaseseq;

    QSqlDatabase database = QSqlDatabase::addDatabase("QMYSQL",databaseseq.setNum(m_index));
    database.setHostName(m_hostname);
    database.setDatabaseName(m_databasename);
    database.setUserName(m_usrname);
    database.setPassword(m_psword);

    if (!database.open())
    {
        database.close();
        qDebug()<<trUtf8("数据库打不开")<<endl;
        return ;
    }
    else
    {
        qDebug()<<trUtf8("线程内数据已经打开")<<endl;
    }


    /*
    QString i2c;
    QFile timelog("timelog"+i2c.setNum(m_index)+".txt");
    if (!timelog.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append))
    {
        qDebug()<<trUtf8("LOG日志没有打开")<<endl;
        return;
    }
    timelog.close();
    */

    QSqlQuery sqlquery(database);
    //    QTime timerecord;
    //    timerecord.start();
    qDebug()<<"sqltest thread runing...";

    mysqldata *data=g_buffer.data();
    mysqldata tempdata;
    bool flag = true;
    while(g_rIndex < DATABLOCKSIZE)
    {
        mutex.lock();
        if(usedBuffer.tryAcquire())
        {            
            flag = false;
            int index=g_rIndex;
            ++g_rIndex;
            qDebug()<<QThread::currentThreadId()<<trUtf8("线程读写第")
                    <<index<<trUtf8("块数据,now数据缓存区内存有 ")<<usedBuffer.available()+1<<" blocks!";

            mutex.unlock();     //先锁住rindex,如果能获取得到资源,就取走该资源。rndex指向该资源。
            tempdata = data[index % 10];

            //qDebug()<<"-";//
            freeBuffer.release();
        }
        else
        {
            mutex.unlock();
            continue;
        }

        int range = tempdata.datavector.size();
        for(int i=0;i <= range/SQLLINE ; ++i)		//i要改成大数,同range
        {
            QString sqlstatement = "";
            int statementnum =( (i+1)*SQLLINE > range ) ? range - i*SQLLINE: SQLLINE;
            sqlstatement="insert into InsertTest("
                    "id,"
                    "taskseq,"
                    "protocoltype ,"
                    "threadnumintask,"
                    "idinthread,"
                    "framesize,"
                    "DestMac,"
                    "SourMac,"
                    "TypeorLength,"
                    "Data,"
                    "Upperlayer) VALUES";


            for(int j=0; j < statementnum; j++)
            {
                sqlstatement += "("+tempdata.idvector.at(i*SQLLINE + j);
                sqlstatement += "," + tempdata.taskseqvector.at(i*SQLLINE + j);
                sqlstatement += ", '" + tempdata.typevector.at(i*SQLLINE + j)+"'";
                sqlstatement += "," + tempdata.threadnumvector.at(i*SQLLINE + j);
                sqlstatement += "," + tempdata.idinthreadvector.at(i*SQLLINE + j);
                sqlstatement += "," + tempdata.framesizevector.at(i*SQLLINE + j);
                sqlstatement += ", '" + tempdata.DestMacvector.at(i*SQLLINE + j)+"'";
                sqlstatement += ", '" + tempdata.SourMacvector.at(i*SQLLINE + j)+"'";
                sqlstatement += ", '" + tempdata.TypeorLengthvector.at(i*SQLLINE + j)+"'";
                sqlstatement += ", '" + tempdata.datavector.at(i*SQLLINE + j)+"'";
                sqlstatement += ", '" + tempdata.uplayervector.at(i*SQLLINE + j)+"')";
                if( j == statementnum -1) sqlstatement += ";";
                else sqlstatement += ",";
            }
            if( statementnum != 0 )
            {
                if(!sqlquery.exec(sqlstatement))
                {
                    qDebug()<<"block--"<<i<<"\t\n"<<sqlquery.lastError().databaseText();
                    qDebug()<<trUtf8("发生语句错误")<<sqlstatement;
                    return;
                }

            }
            else
            {
                break;
            }
        }


    }




    //    timelog.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append);
    //    QTextStream logout(&timelog);
    //    logout << "Insert "<<m_range<<" Lines to SQL need time : " << timerecord.elapsed() << "(ms)\n";
    //    timelog.close();


    database.close();
    qDebug()<<m_index<<"_thread run over!"<<endl;
}
Пример #5
0
void tst_QSemaphore::acquire()
{
    {
        // old incrementOne() test
        QVERIFY(!semaphore);
        semaphore = new QSemaphore;
        // make some "thing" available
        semaphore->release();

        ThreadOne t1;
        ThreadOne t2;

        t1.start();
        t2.start();

        QVERIFY(t1.wait(4000));
        QVERIFY(t2.wait(4000));

        delete semaphore;
        semaphore = 0;
    }

    // old incrementN() test
    {
        QVERIFY(!semaphore);
        semaphore = new QSemaphore;
        // make 4 "things" available
        semaphore->release(4);

        ThreadN t1(2);
        ThreadN t2(3);

        t1.start();
        t2.start();

        QVERIFY(t1.wait(4000));
        QVERIFY(t2.wait(4000));

        delete semaphore;
        semaphore = 0;
    }

    QSemaphore semaphore;

    QCOMPARE(semaphore.available(), 0);
    semaphore.release();
    QCOMPARE(semaphore.available(), 1);
    semaphore.release();
    QCOMPARE(semaphore.available(), 2);
    semaphore.release(10);
    QCOMPARE(semaphore.available(), 12);
    semaphore.release(10);
    QCOMPARE(semaphore.available(), 22);

    semaphore.acquire();
    QCOMPARE(semaphore.available(), 21);
    semaphore.acquire();
    QCOMPARE(semaphore.available(), 20);
    semaphore.acquire(10);
    QCOMPARE(semaphore.available(), 10);
    semaphore.acquire(10);
    QCOMPARE(semaphore.available(), 0);
}
Пример #6
0
void tst_QSemaphore::tryAcquireWithTimeout()
{
    QFETCH(int, timeout);

    // timers are not guaranteed to be accurate down to the last millisecond,
    // so we permit the elapsed times to be up to this far from the expected value.
    int fuzz = 50;

    QSemaphore semaphore;
    QElapsedTimer time;

#define FUZZYCOMPARE(a,e) \
    do { \
        int a1 = a; \
        int e1 = e; \
        QVERIFY2(qAbs(a1-e1) < fuzz, \
            qPrintable(QString("(%1=%2) is more than %3 milliseconds different from (%4=%5)") \
                        .arg(#a).arg(a1).arg(fuzz).arg(#e).arg(e1))); \
    } while (0)

    QCOMPARE(semaphore.available(), 0);

    semaphore.release();
    QCOMPARE(semaphore.available(), 1);
    time.start();
    QVERIFY(!semaphore.tryAcquire(2, timeout));
    FUZZYCOMPARE(time.elapsed(), timeout);
    QCOMPARE(semaphore.available(), 1);

    semaphore.release();
    QCOMPARE(semaphore.available(), 2);
    time.start();
    QVERIFY(!semaphore.tryAcquire(3, timeout));
    FUZZYCOMPARE(time.elapsed(), timeout);
    QCOMPARE(semaphore.available(), 2);

    semaphore.release(10);
    QCOMPARE(semaphore.available(), 12);
    time.start();
    QVERIFY(!semaphore.tryAcquire(100, timeout));
    FUZZYCOMPARE(time.elapsed(), timeout);
    QCOMPARE(semaphore.available(), 12);

    semaphore.release(10);
    QCOMPARE(semaphore.available(), 22);
    time.start();
    QVERIFY(!semaphore.tryAcquire(100, timeout));
    FUZZYCOMPARE(time.elapsed(), timeout);
    QCOMPARE(semaphore.available(), 22);

    time.start();
    QVERIFY(semaphore.tryAcquire(1, timeout));
    FUZZYCOMPARE(time.elapsed(), 0);
    QCOMPARE(semaphore.available(), 21);

    time.start();
    QVERIFY(semaphore.tryAcquire(1, timeout));
    FUZZYCOMPARE(time.elapsed(), 0);
    QCOMPARE(semaphore.available(), 20);

    time.start();
    QVERIFY(semaphore.tryAcquire(10, timeout));
    FUZZYCOMPARE(time.elapsed(), 0);
    QCOMPARE(semaphore.available(), 10);

    time.start();
    QVERIFY(semaphore.tryAcquire(10, timeout));
    FUZZYCOMPARE(time.elapsed(), 0);
    QCOMPARE(semaphore.available(), 0);

    // should not be able to acquire more
    time.start();
    QVERIFY(!semaphore.tryAcquire(1, timeout));
    FUZZYCOMPARE(time.elapsed(), timeout);
    QCOMPARE(semaphore.available(), 0);

    time.start();
    QVERIFY(!semaphore.tryAcquire(1, timeout));
    FUZZYCOMPARE(time.elapsed(), timeout);
    QCOMPARE(semaphore.available(), 0);

    time.start();
    QVERIFY(!semaphore.tryAcquire(10, timeout));
    FUZZYCOMPARE(time.elapsed(), timeout);
    QCOMPARE(semaphore.available(), 0);

    time.start();
    QVERIFY(!semaphore.tryAcquire(10, timeout));
    FUZZYCOMPARE(time.elapsed(), timeout);
    QCOMPARE(semaphore.available(), 0);

#undef FUZZYCOMPARE
}
Пример #7
0
void tst_QSemaphore::tryAcquire()
{
    QSemaphore semaphore;

    QCOMPARE(semaphore.available(), 0);

    semaphore.release();
    QCOMPARE(semaphore.available(), 1);
    QVERIFY(!semaphore.tryAcquire(2));
    QCOMPARE(semaphore.available(), 1);

    semaphore.release();
    QCOMPARE(semaphore.available(), 2);
    QVERIFY(!semaphore.tryAcquire(3));
    QCOMPARE(semaphore.available(), 2);

    semaphore.release(10);
    QCOMPARE(semaphore.available(), 12);
    QVERIFY(!semaphore.tryAcquire(100));
    QCOMPARE(semaphore.available(), 12);

    semaphore.release(10);
    QCOMPARE(semaphore.available(), 22);
    QVERIFY(!semaphore.tryAcquire(100));
    QCOMPARE(semaphore.available(), 22);

    QVERIFY(semaphore.tryAcquire());
    QCOMPARE(semaphore.available(), 21);

    QVERIFY(semaphore.tryAcquire());
    QCOMPARE(semaphore.available(), 20);

    QVERIFY(semaphore.tryAcquire(10));
    QCOMPARE(semaphore.available(), 10);

    QVERIFY(semaphore.tryAcquire(10));
    QCOMPARE(semaphore.available(), 0);

    // should not be able to acquire more
    QVERIFY(!semaphore.tryAcquire());
    QCOMPARE(semaphore.available(), 0);

    QVERIFY(!semaphore.tryAcquire());
    QCOMPARE(semaphore.available(), 0);

    QVERIFY(!semaphore.tryAcquire(10));
    QCOMPARE(semaphore.available(), 0);

    QVERIFY(!semaphore.tryAcquire(10));
    QCOMPARE(semaphore.available(), 0);
}
Пример #8
0
void tst_QSemaphore::tryAcquireWithTimeout()
{
    QFETCH(int, timeout);

    QSemaphore semaphore;
    QTime time;


    QCOMPARE(semaphore.available(), 0);

    semaphore.release();
    QCOMPARE(semaphore.available(), 1);
    time.start();
    QVERIFY(!semaphore.tryAcquire(2, timeout));
    QVERIFY(time.elapsed() >= timeout);
    QCOMPARE(semaphore.available(), 1);

    semaphore.release();
    QCOMPARE(semaphore.available(), 2);
    time.start();
    QVERIFY(!semaphore.tryAcquire(3, timeout));
    QVERIFY(time.elapsed() >= timeout);
    QCOMPARE(semaphore.available(), 2);

    semaphore.release(10);
    QCOMPARE(semaphore.available(), 12);
    time.start();
    QVERIFY(!semaphore.tryAcquire(100, timeout));
    QVERIFY(time.elapsed() >= timeout);
    QCOMPARE(semaphore.available(), 12);

    semaphore.release(10);
    QCOMPARE(semaphore.available(), 22);
    time.start();
    QVERIFY(!semaphore.tryAcquire(100, timeout));
    QVERIFY(time.elapsed() >= timeout);
    QCOMPARE(semaphore.available(), 22);

    time.start();
    QVERIFY(semaphore.tryAcquire(1, timeout));
    QVERIFY(time.elapsed() <= timeout);
    QCOMPARE(semaphore.available(), 21);

    time.start();
    QVERIFY(semaphore.tryAcquire(1, timeout));
    QVERIFY(time.elapsed() <= timeout);
    QCOMPARE(semaphore.available(), 20);

    time.start();
    QVERIFY(semaphore.tryAcquire(10, timeout));
    QVERIFY(time.elapsed() <= timeout);
    QCOMPARE(semaphore.available(), 10);

    time.start();
    QVERIFY(semaphore.tryAcquire(10, timeout));
    QVERIFY(time.elapsed() <= timeout);
    QCOMPARE(semaphore.available(), 0);

    // should not be able to acquire more
    time.start();
    QVERIFY(!semaphore.tryAcquire(1, timeout));
    QVERIFY(time.elapsed() >= timeout);
    QCOMPARE(semaphore.available(), 0);

    time.start();
    QVERIFY(!semaphore.tryAcquire(1, timeout));
    QVERIFY(time.elapsed() >= timeout);
    QCOMPARE(semaphore.available(), 0);

    time.start();
    QVERIFY(!semaphore.tryAcquire(10, timeout));
    QVERIFY(time.elapsed() >= timeout);
    QCOMPARE(semaphore.available(), 0);

    time.start();
    QVERIFY(!semaphore.tryAcquire(10, timeout));
    QVERIFY(time.elapsed() >= timeout);
    QCOMPARE(semaphore.available(), 0);
}
Пример #9
0
// Fonction principale de l'application
//
int main(int argc, char **argv)
{
	int lancement=true;			// Drapeau pour savoir si on doit lancer l'application
	int ArretSystemeEnQuittant=false;	// Drapeau pour le lancement de l'arret du systeme en quittant l'application
	int retour=0;				// Valeur de retour de la fin de l'application
	
	// Renseignements KDE
	//
	KAboutData about("cameroa", I18N_NOOP("CamerOA"), version, description,KAboutData::License_GPL, "(C) 2006 David Romeuf", 0, 0, "*****@*****.**");
	about.addAuthor( "David Romeuf", 0, "*****@*****.**" );
	
	
	// Initialisation des options de la ligne de commande (avec les Qt et KDE specifiques)
	//
	KCmdLineArgs::init(argc, argv, &about);
	
	// Ajout des options possibles sur la ligne de commande supportees par l'application
	//
	KCmdLineArgs::addCmdLineOptions(options);
	
	// Acces aux arguments reconnus par l'application
	//
	KCmdLineArgs *arguments=KCmdLineArgs::parsedArgs();
	
	// On test la validite des arguments
	//
	if( !QDir(arguments->getOption(OptionsLC[CheminRepCamerOA])).exists() )
	{
		std::cerr << "CamerOA: ERREUR: Le repertoire " << arguments->getOption(OptionsLC[CheminRepCamerOA]) << " n'existe pas." << std::endl;
		lancement=false;
	}
	
	struct in_addr AdresseClient;
	
	if( !inet_aton(arguments->getOption(OptionsLC[AdresseClientAutorise]),&AdresseClient) )
	{
		std::cerr << "CamerOA: ERREUR: L'adresse du client autorise " << arguments->getOption(OptionsLC[AdresseClientAutorise]) << "est invalide." << std::endl;
		lancement=false;
	}
	AdresseClient.s_addr=ntohl(AdresseClient.s_addr);
	
	if( QString(arguments->getOption(OptionsLC[ArretSysteme])) == QString("o") ) ArretSystemeEnQuittant=true;
	
	
	if( lancement )
	{
		// Instanciation de l'objet camera :
		//
		// ApnCamera.cpp contient le code de la classe CApnCamera definit dans ApnCamera.h commun
		//  a toutes les versions d'interfaces peripheriques (USB, Ethernet). Aucun code n'est
		//  specialise USB/Linux.
		//
		// ApnCamera_USB.cpp contient le code de la classe CApnCamera definit dans ApnCamera.h
		//  specialise pour la version USB (par exemple la methode InitDriver() qui n'est pas
		//  codee dans ApnCamera.cpp).
		//
		// ApogeeUsbLinux.cpp contient toutes les fonctions de communication via USB pour Linux
		//  utilisees par l'objet CApnCamera (par exemple : ApnUsbOpen() qui recherche les
		//  peripheriques par Id vendeur, ApnUsbClose()).
		//
#ifndef _SIMULATEUR_APOGEE
		CameraCCD=new CApnCamera();
#else
		CameraCCD=new SimulateurApogeeUSB(false);
#endif

		// Initialisation du systeme de la camera et test de communication USB
		//
		// Le numero de camera est celui trouve par ordre d'Id vendeur Apogee en scannant tous
		//  les bus USB.
		//
		if( !CameraCCD->InitDriver(NumeroCamera,0,0) )
		{
			std::cout << "CamerOA: ERREUR: Impossible d'initialiser le systeme de la camera." << std::endl;
			exit(EXIT_FAILURE);
		}

		// Reinitialisation complete du systeme de la camera et permission du flushing (vidage)
		//  FPGA_BIT_CMD_FLUSH
		//
		if( !CameraCCD->ResetSystem() )
		{
			std::cout << "CamerOA: ERREUR: Impossible de reinitialiser le systeme de la camera." << std::endl;
			exit(EXIT_FAILURE);
		}

		// Recuperation des informations de la camera (version Linux speciale dans
		//  ApnCamera_Linux.cpp)
		//
		CameraCCD->sensorInfo();

		// Mode de fonctionnement de la camera
		//
		CameraCCD->write_CameraMode(Apn_CameraMode_Normal);

		// Parametrage du mode des diodes LED sur la camera
		//
		//  Apn_LedMode_DisableAll, Apn_LedMode_DisableWhileExpose, Apn_LedMode_EnableAll
		//
		CameraCCD->write_LedMode(Apn_LedMode_EnableAll);

		// Puissance lumineuse des diodes LED
		//
		CameraCCD->write_TestLedBrightness(100.0);

		// Fonction de la LED A
		//
		CameraCCD->write_LedState(0,Apn_LedState_Flushing);

		// Fonction de la LED B
		//
		CameraCCD->write_LedState(1,Apn_LedState_ImageActive);

		// Allocation memoire des buffers pixels physiques pour cette camera
		//
		// Il s'agit du nombre de pixels physiques et pas surface image du capteur pour avoir de la marge
		//
		if( (BufferPixelsPhysiquesImage=new (std::nothrow) unsigned short[CameraCCD->m_TotalRows*CameraCCD->m_TotalColumns]) == NULL )
		{
			std::cout << "CamerOA: ERREUR: Impossible d'allouer le buffer pixels physiques image pour cette camera." << std::endl;
			exit(EXIT_FAILURE);
		}

		if( (BufferPixelsPhysiquesVidage=new (std::nothrow) unsigned short[CameraCCD->m_TotalRows*CameraCCD->m_TotalColumns]) == NULL )
		{
			std::cout << "CamerOA: ERREUR: Impossible d'allouer le buffer pixels physiques vidage pour cette camera." << std::endl;
			exit(EXIT_FAILURE);
		}

		if( (BufferPixelsPhysiquesCentrage=new (std::nothrow) unsigned short[CameraCCD->m_TotalRows*CameraCCD->m_TotalColumns]) == NULL )
		{
			std::cout << "CamerOA: ERREUR: Impossible d'allouer le buffer pixels physiques centrage pour cette camera." << std::endl;
			exit(EXIT_FAILURE);
		}

		// Allocation memoire du buffer pixels d'une pose de centrage horizontal
		//
		if( (BufferPixelsPCH=new (std::nothrow) unsigned short[NB_LIGNES_POSE_CENTRAGE*CameraCCD->m_ImagingColumns/BINNING_POSE_CENTRAGE]) == NULL )
		{
			std::cout << "CamerOA: ERREUR: Impossible d'allouer le buffer pixels d'une pose de centrage horizontal pour cette camera." << std::endl;
			exit(EXIT_FAILURE);
		}

		// Allocation memoire du buffer pixels d'une pose de centrage vertical
		//
		if( (BufferPixelsPCV=new (std::nothrow) unsigned short[NB_COLONNES_POSE_CENTRAGE*CameraCCD->m_ImagingRows/BINNING_POSE_CENTRAGE]) == NULL )
		{
			std::cout << "CamerOA: ERREUR: Impossible d'allouer le buffer pixels d'une pose de centrage vertical pour cette camera." << std::endl;
			exit(EXIT_FAILURE);
		}


		// Creation d'un objet application KDE
		//
		KApplication appli;
		
		// Pointeur sur un objet de fenetre principale KDE
		//
		CamerOA *FenetrePrincipale=0;		// Pointeur sur objet fenetre principale de notre application

		// Instanciation du processus leger de controle de la camera
		//
		// ATTENTION: On le fait avant la fenetre principale car celle-ci a besoin d'un pointeur
		//  vers le thread de controle de la camera
		//
		ProcessusLegerControleCamera PLCamera;

		// Si l'application est restauree par le gestionnaire de session
		//
		if( appli.isRestored() )
		{
			// On restaure l'application a l'aide de l'objet de configuration de la session sauve lors de la fermeture de session
			//
			RESTORE(CamerOA(arguments->getOption(OptionsLC[CheminRepCamerOA]),&appli,&PLCamera));
		}
		else
		{
			// Pas de restauration de session donc on demarre l'application normalement
			//
			
			// Creation de l'objet fenetre principale de l'application
			//
			if( (FenetrePrincipale=new (std::nothrow) CamerOA(arguments->getOption(OptionsLC[CheminRepCamerOA]),&appli,&PLCamera)) == NULL )
			{
    				std::cerr << "CamerOA: ERREUR: Impossible de creer la fenetre principale KMainWindow de l'application." << std::endl;
					appli.exit(-1);
			}

			// Le processus leger de controle de la camera contient un pointeur vers la fenetre
			//   principale de l'application
			//
			// ATTENTION: Il faut le placer immediatement apres la creation de la fenetre 
			//  principale de l'application car le thread utilise ses methodes
			//
			PLCamera.FPCamerOA=FenetrePrincipale;

			// On fixe la fenetre principale pour l'objet application KDE
			//
			appli.setMainWidget(FenetrePrincipale);
		
			// On fixe quelques proprietes de la fenetre principale heritees de QWidget
			//
			FenetrePrincipale->setMinimumSize(QSize(TAILLE_X_BASE_CAMEROA,TAILLE_Y_BASE_CAMEROA));
		
			// Chargement des consignes sauvegardees
			//
			if( !FenetrePrincipale->ChargeConsignes() ) exit(EXIT_FAILURE);
		}
		
		// Lancement du processus leger serveur reseau des commandes sur le CamerOA
		//
		ProcessusLegerServeurCommandes PLServeurCommandes(FenetrePrincipale,INADDR_ANY,QString(arguments->getOption(OptionsLC[PortCanalCommandes])).toInt(),AdresseClient.s_addr,2,TIMEOUT_EMISSION,TIMEOUT_RECEPTION,5,FnHandlerSIGPIPECamerOA,arguments->getOption(OptionsLC[MdpClePriveeServeur]),MotDePasseClePriveeServeurCAMEROA,FnMotDePasseClePriveeChiffreeCAMEROA,arguments->getOption(OptionsLC[CheminFichCertCA_OA]),arguments->getOption(OptionsLC[CheminFichCertServCamerOA]),arguments->getOption(OptionsLC[CheminFichClePriveeServCamerOA]),arguments->getOption(OptionsLC[CheminFichParamDH]),"HIGH");

		FenetrePrincipale->PLServeurCommandes=&PLServeurCommandes;
		
		PLServeurCommandes.start();
		
		// Lancement du processus leger serveur reseau des donnees sur le CamerOA
		//
		ProcessusLegerServeurDonnees PLServeurDonnees(FenetrePrincipale,INADDR_ANY,QString(arguments->getOption(OptionsLC[PortCanalDonnees])).toInt(),AdresseClient.s_addr,2,TIMEOUT_EMISSION,TIMEOUT_RECEPTION);

		FenetrePrincipale->PLServeurDonnees=&PLServeurDonnees;
		
		PLServeurDonnees.start();
		
		// Les pointeurs entre les processus
		//
		PLServeurCommandes.threadCanalDonnees=&PLServeurDonnees;
		PLServeurCommandes.threadCamera=&PLCamera;
		
		// Lancement du processus leger de controle de la camera
		//
		PLCamera.start();
		
		// Tant que les threads ne sont pas tous lances et operationnels
		//
		while( SemaphoreSyncLancementThreadCamerOA.available() > 0 );
		
		// On affiche la fenetre principale
		//
		FenetrePrincipale->show();
		
		// Demarrage du timer une fois que tout est lance et affiche
		//
		FenetrePrincipale->Pulsar1s->start(1000,FALSE);
		
		
		// FenetrePrincipale a un drapeau WDestructiveClose par defaut, elle se detruira elle meme.
		//
		retour=appli.exec();


		//	On demande l'arret des processus legers
		//
		if( PLServeurCommandes.running() )
		{
			PLServeurCommandes.DemandeTerminaison();
		}

		if( PLServeurDonnees.running() )
		{
			PLServeurDonnees.DemandeTerminaison();
		}

		if( PLCamera.running() )
		{
			PLCamera.DemandeTerminaison();
		}

		// Si le processus leger de controle de la camera tourne encore
		//  on attend la terminaison propre par lui meme
		//
		while( PLCamera.running() );
		PLCamera.wait(TEMPS_ATTENTE_TERMINAISON_PROCESSUS_LEGER);

		// Fermeture de la communication USB avec la camera
		//
		CameraCCD->write_ForceShutterOpen(false);
		CameraCCD->ResetSystem();
		usleep(1000000);
		CameraCCD->CloseDriver();
		
		// On attend la terminaison du processus leger avant de retourner la valeur
		//
		PLServeurCommandes.wait(TEMPS_ATTENTE_TERMINAISON_PROCESSUS_SERVEUR);

		// On attend la terminaison du processus leger avant de retourner la valeur
		//
		PLServeurDonnees.wait(TEMPS_ATTENTE_TERMINAISON_PROCESSUS_SERVEUR);

		
		// On lave la liste des options et arguments de la ligne de commande de l'application
		//
		arguments->clear();
		
		
		// Destruction de l'objet camera
		//
		delete CameraCCD;
		
		
		// Liberation de la memoire utilisee pour la gestion de la camera
		//
		delete [] BufferPixelsPhysiquesImage;
		delete [] BufferPixelsPhysiquesVidage;
		delete [] BufferPixelsPhysiquesCentrage;
		delete [] BufferPixelsPCH;
		delete [] BufferPixelsPCV;


		// Si on a demande l'arret du systeme en quittant l'application CamerOA
		//
		if( ArretSystemeEnQuittant )
		{
			std::cout << "Lancement de la demande de l'arret du systeme dans 60 secondes." << std::endl;
			
			// On utilise la commande propre du systeme via la commande sudo
			//
			// Il faut installer l'utilitaire sudo et configurer /etc/sudoers avec la ligne :
			//
			//  dromeuf cameroa-1=NOPASSWD: /sbin/halt
			//	observateur cameroa-1=NOPASSWD: /sbin/halt
			//
			//  qui permet par exemple a l'utilisateur dromeuf depuis la machine jedi, sans mot de passe,
			//   de lancer la commande /sbin/halt
			//
			system("/bin/sync ; /bin/sleep 60s ; /usr/bin/sudo /sbin/halt");
		}

		// Resultat de l'execution de la QApplication heritee par KApplication
		//
		return retour;
	}
}
Пример #10
0
 ~AutoSem() {
     if (s->available() > 0)
         s->acquire(s->available());
 }