コード例 #1
0
int main(int argc, char *argv[])
{
	const KAboutData about(
		"konstruktor", "konstruktor",
		ki18n("Part database updater for Konstruktor"), "0.9.0-beta1",
		ki18n("Updates the part database. Must be called internally by Konstruktor."),
		KAboutData::License_GPL_V3,
		ki18n("(c)2006-2011, Park \"segfault\" Joon-Kyu"));
	
	KCmdLineArgs::init(argc, argv, &about);

	KCmdLineOptions options;
	options.add("+[location]", ki18n("Path to LDraw part library"));
	options.add("rescan", ki18n("Rescan the entire library"));
	KCmdLineArgs::addCmdLineOptions(options);
	
	KApplication app;

	int status;
	try {
		Konstruktor::DBUpdater updater;
		
		status = updater.start();
	} catch (const std::runtime_error &e) {
		QMessageBox::critical(0L, i18n("Error"), QString(e.what()));

		status = -1;
	}
	
	app.exit(status);

	return status;
}
コード例 #2
0
ファイル: main.cpp プロジェクト: maelvalais/cameroa
// 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;
	}
}