Exemple #1
0
int main(int argc, char *argv[])
{
    if (argc == 3) {
        try {
            AHRS *imu = new AHRS(std::string(argv[1]),getBaudrate(argv[2]));
            char *buffer = NULL;
            size_t bufsize;
            // Connect to the AHRS.
            imu->openDevice();
            printf("Connected to %s.\n", (imu->getInfo()).c_str());
            // Prompt the user for a new baudrate.
            printf("New speed? (baud) \n");
            if (getline(&buffer, &bufsize, stdin) == -1)
            {
                fprintf(stderr, "Unable to read in new baudrate.\n");
                imu->closeDevice();
                return -1;
            }
            // Attempt to read in a baudrate and change to it.
            imu->setBaudrate(getBaudrate(buffer));
            // Clean up and close resources.
            free(buffer);
            imu->closeDevice();
            // Tell the user of the result.
            fprintf(stderr, "Changed speed successfully.\n");
            exit(0);
        } catch (std::exception& e) {
            printError(e);
        }
    }
    printUsage();
}
Exemple #2
0
int main(int argc, char *argv[])
{
   if (argc == 3) {
      try {
         DVL *dvl = new DVL(std::string(argv[1]),getBaudrate(argv[2]));
         DVL::SystemConfig config;
         char *buffer = NULL;
         size_t bufsize;
         // Prompt the user for a new baudrate.
         printf("New speed? (baud) \n");
         if (getline(&buffer, &bufsize, stdin) == -1)
         {
            fprintf(stderr, "Unable to read in new baudrate.\n");
            dvl->closeDevice();
            return -1;
         }
         // Read in the baudrate and change the device speed.
         config.speed = getBaudrate(buffer);


         // Clean up and close resources.
         free(buffer);
         dvl->closeDevice();
         // Tell the user of the result.
         fprintf(stderr, "Changed speed successfully.\n");
         exit(0);
      } catch (std::exception& e) {
         printError(e);
      }
   }
   printUsage();
}
/*	Open connection.
*	Returns 1 if ESP8266 is responding, 0 otherwise.
*/
bool ArduEsp8266::init(){

	// init serial debugging interface
	if( useDebug() ){
		debug.begin(115200);
		debug.println("init esp8266 wifi module ...");
	}

	if( getEnablePin() >= 0 ){
		pinMode( getEnablePin(), OUTPUT );
		digitalWrite( getEnablePin(), HIGH );
		delay(2000);
	}
	
	// init serial port
	Serial.begin( getBaudrate() );

	if( isConnected() ){
		// try to disable echo
		setEcho(false);
		return true;
	}
	
	return false;
}
/*
 * Class:     abel_serialport_SerialPort
 * Method:    open
 * Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor;
 */
JNIEXPORT jobject JNICALL Java_abel_serialport_SerialPort_open
  (JNIEnv *env, jclass clazz, jstring path, jint baudrate, jint flags)
{
	speed_t speed = getBaudrate(baudrate);
	if (speed == -1) {
		LOGE("Invalid baudrate");
		return NULL;
	}

    int fd;
    jboolean iscopy;
    const char *path_utf = (*env)->GetStringUTFChars(env, path, &iscopy);
    fd = open(path_utf, O_RDWR | O_NOCTTY | flags);
    (*env)->ReleaseStringUTFChars(env, path, path_utf);
    if (fd == -1)
    {
        /* Throw an exception */
        LOGE("Cannot open port");
        /* TODO: throw an exception */
        return NULL;
    }

	struct termios cfg;
	if (tcgetattr(fd, &cfg))
	{
		LOGE("tcgetattr() failed");
		close(fd);
		return NULL;
	}

	cfmakeraw(&cfg);
	cfsetispeed(&cfg, speed);
	cfsetospeed(&cfg, speed);

	cfg.c_cflag &= ~(HUPCL | CLOCAL);
	LOGD("%s cflag: %X", path_utf, cfg.c_cflag);
	LOGD("%s lflag: %X", path_utf, cfg.c_lflag);
	LOGD("%s iflag: %X", path_utf, cfg.c_iflag);
	LOGD("%s oflag: %X", path_utf, cfg.c_oflag);

	if (tcsetattr(fd, TCSANOW, &cfg))
	{
		LOGE("tcsetattr() failed");
		close(fd);
		/* TODO: throw an exception */
		return NULL;
	}

	jclass cFileDescriptor = (*env)->FindClass(env, "java/io/FileDescriptor");
	jmethodID iFileDescriptor = (*env)->GetMethodID(env, cFileDescriptor, "<init>", "()V");
	jfieldID descriptorID = (*env)->GetFieldID(env, cFileDescriptor, "descriptor", "I");
	jobject fileDescriptor = (*env)->NewObject(env, cFileDescriptor, iFileDescriptor);
	(*env)->SetIntField(env, fileDescriptor, descriptorID, (jint)fd);
	return fileDescriptor;
}
Exemple #5
0
JNIEXPORT jint JNICALL
Java_firich_com_firichsdk_SerialPort_openSerialPort(JNIEnv *env, jobject instance, jstring path_,
                                                    jint baudrate) {
    const char *path = (*env)->GetStringUTFChars(env, path_, 0); //Android Java String convert to C char*

    struct termios tio;

    memset(&tio,0,sizeof(tio));
    tio.c_iflag=0;
    tio.c_oflag=0;
    tio.c_cflag=CS8|CREAD|CLOCAL;           // 8n1, see termios.h for more information
    tio.c_lflag=0;
    tio.c_cc[VMIN]=1;
    tio.c_cc[VTIME]=5;
    int tty_fd=open(path, O_RDWR | O_NONBLOCK);
    cfsetospeed(&tio,getBaudrate(baudrate));
    cfsetispeed(&tio,getBaudrate(baudrate));

    tcsetattr(tty_fd,TCSANOW,&tio);
    return tty_fd; //  C char convert to Android Java String
}
Exemple #6
0
int main(int argc, char *argv[])
{
   if (argc == 3) {
      try {
         AHRS *ahrs = new AHRS(std::string(argv[1]),getBaudrate(argv[2]));
         AHRS::AcqConfig config;
         AHRS::FilterData filters;
         long unsigned int i;

         ahrs->openDevice();
         printf("Connected to %s.\n", (ahrs->getInfo()).c_str());

         ahrs->sendAHRSDataFormat();

         printf("AHRS Configuration data:\n");

         config = ahrs->getAcqConfig();
         printf("Acqusition mode:   %d\n", config.poll_mode);
         printf("Flush Filter:      %d\n", config.flush_filter);
         printf("Sample delay:      %f\n", config.sample_delay);

         filters = ahrs->getFIRFilters();
         printf("Number of filters: %lu\n", filters.size());
         for (i=0; i < filters.size(); i++)
         printf("Filter #%.2lu:        %f\n",i, filters[i]);

         printf("Mag Truth Method:  %d\n", ahrs->getMagTruthMethod());
         printf("Functional mode:   %d\n", ahrs->getAHRSMode());
         printf("Declination:       %f\n", ahrs->getDeclination());
         printf("UserCalNumPoints:  %d\n", ahrs->getCalPoints());
         printf("Mag Setting:       %d\n", ahrs->getMagCalID());
         printf("Accel setting:     %d\n", ahrs->getAccelCalID());
         printf("Mounting mode:     %d\n", ahrs->getMounting());
         printf("Baudrate:          %d\n", ahrs->getBaudrate().baud);
         printf("True north?        %d\n", ahrs->getTrueNorth());
         printf("Big endian?        %d\n", ahrs->getBigEndian());
         printf("Auto sampling?     %d\n", ahrs->getAutoCalibration());
         printf("Mils/Degrees?      %d\n", ahrs->getMils());
         printf("HPR During Cal?    %d\n", ahrs->getHPRCal());
         ahrs->closeDevice();
         exit(0);
      }
      catch (std::exception& e)
      {
         printError(e);
      }
   } 
   printUsage();
}
Exemple #7
0
/* first parse all options, and save arguments in the sessions struct
 * exit on any error encountered, if none present, proceed and return */
void setOptions(int argc, const char * argv[]) {
	int ret;
	bool printVersion = false;

	poptContext optCon = poptGetContext(NULL, argc, argv, options, 0);

	options[0].arg = elbowOptionsTable;

	while ((ret = poptGetNextOpt(optCon)) > 0) {
		switch (ret) {

			case PR_EOL:
				settings.eol = getEndOfLine(settings.eol);
				break;

			case PR_BAUDRATE:
				settings.rate = getBaudrate(settings.rate);
				break;

			case PR_VERSION:
				printVersion = true;
				break;
		}
	}

	/* report parsing error if present and exit */
	if (ret < -1) {
		printf("\n%s: %s\n\n", poptStrerror(ret), poptBadOption(optCon, 0));
		poptPrintHelp(optCon, stdout, 0);
		exit(EXIT_FAILURE);
	}

	/* print version information and exit */
	if (printVersion) {
		printf("Elbow version %s\n", VERSION);
		printf("Copyright (C) %s  %s\n", YEAR, AUTHOR);
		printf("Released under the %s license.\n", LICENSE);
		printf("\n%s\n", DISCLAIMER);
	}

	optCon = poptFreeContext(optCon);
}
Exemple #8
0
/*
 * Class:     android_serialport_SerialPort
 * Method:    open
 * Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor;
 */
JNIEXPORT jobject JNICALL  Java_com_bw_serial_SerialPort_open
  (JNIEnv *env, jclass thiz, jstring path, jint baudrate, jint flags)
{
        int fd;
        speed_t speed;
        jobject mFileDescriptor;

        /* Check arguments */
        {
                speed = getBaudrate(baudrate);
                if (speed == -1) {
                        /* TODO: throw an exception */
                        LOGE("Invalid baudrate");
                        return NULL;
                }
        }

        /* Opening device */
        {
                jboolean iscopy;
                const char *path_utf = (*env)->GetStringUTFChars(env, path, &iscopy);
                LOGD("Opening serial port %s with flags 0x%x", path_utf, O_RDWR | flags);
                fd = open(path_utf, O_RDWR | flags);
                LOGD("open() fd = %d", fd);
                (*env)->ReleaseStringUTFChars(env, path, path_utf);
                if (fd == -1)
                {
                        /* Throw an exception */
                        LOGE("Cannot open port");
                        /* TODO: throw an exception */
                        return NULL;
                }
        }

        /* Configure device */
        {
                struct termios cfg;
                LOGD("Configuring serial port");
                if (tcgetattr(fd, &cfg))
                {
                        LOGE("tcgetattr() failed");
                        close(fd);
                        /* TODO: throw an exception */
                        return NULL;
                }

                cfmakeraw(&cfg);
                cfsetispeed(&cfg, speed);
                cfsetospeed(&cfg, speed);

                if (tcsetattr(fd, TCSANOW, &cfg))
                {
                        LOGE("tcsetattr() failed");
                        close(fd);
                        /* TODO: throw an exception */
                        return NULL;
                }
        }

        /* Create a corresponding file descriptor */
        {
                jclass cFileDescriptor = (*env)->FindClass(env, "java/io/FileDescriptor");
                jmethodID iFileDescriptor = (*env)->GetMethodID(env, cFileDescriptor, "<init>", "()V");
                jfieldID descriptorID = (*env)->GetFieldID(env, cFileDescriptor, "descriptor", "I");
                mFileDescriptor = (*env)->NewObject(env, cFileDescriptor, iFileDescriptor);
                (*env)->SetIntField(env, mFileDescriptor, descriptorID, (jint)fd);
        }

        return mFileDescriptor;
}
Exemple #9
0
static int set_opt(int fd,int nSpeed, int nBits, char nEvent, int nStop)
{
	struct termios newtio,oldtio;
	speed_t speedbt;
	/*保存测试现有串口参数设置,在这里如果串口号等出错,会有相关的出错信息*/
	if ( tcgetattr( fd,&oldtio) != 0)
	{
		perror("SetupSerial 1");
		return -1;
	}
	bzero( &newtio, sizeof( newtio ) );
	/*步骤一,设置字符大小*/
	newtio.c_cflag |= CLOCAL | CREAD;
	newtio.c_cflag &= ~CSIZE;
	/*设置停止位*/
	switch( nBits )
	{
		case 7:
			newtio.c_cflag |= CS7;
			break;
		case 8:
			newtio.c_cflag |= CS8;
			break;
	}
	/*设置奇偶校验位*/
	switch( nEvent )
	{
		case 'O': //奇数
			newtio.c_cflag |= PARENB;
			newtio.c_cflag |= PARODD;
			newtio.c_iflag |= INPCK;
			break;
		case 'E': //偶数
			newtio.c_iflag |= INPCK;
			newtio.c_cflag |= PARENB;
			newtio.c_cflag &= ~PARODD;
			break;
		case 'N': //无奇偶校验位
			newtio.c_cflag &= ~PARENB;
			break;
	}
	/*设置波特率*/
	speedbt = getBaudrate(nSpeed);
	if (speedbt < 0) {
		LOGD("-------------getBaudrate error %d\n", nSpeed);
		return -1;
	}
	cfsetispeed(&newtio, speedbt);
	cfsetospeed(&newtio, speedbt);
#if 0
	switch( nSpeed )
	{
		case 2400:
			cfsetispeed(&newtio, B2400);
			cfsetospeed(&newtio, B2400);
			break;
		case 4800:
			cfsetispeed(&newtio, B4800);
			cfsetospeed(&newtio, B4800);
			break;
		case 9600:
			cfsetispeed(&newtio, B9600);
			cfsetospeed(&newtio, B9600);
			break;
		case 115200:
			cfsetispeed(&newtio, B115200);
			cfsetospeed(&newtio, B115200);
			break;
		case 460800:
			cfsetispeed(&newtio, B460800);
			cfsetospeed(&newtio, B460800);
			break;
		default:
			cfsetispeed(&newtio, B9600);
			cfsetospeed(&newtio, B9600);
			break;
	}
#endif

	/*设置停止位*/
	if( nStop == 1 )
		newtio.c_cflag &= ~CSTOPB;
	else if ( nStop == 2 )
		newtio.c_cflag |= CSTOPB;
	/*设置等待时间和最小接收字符*/
	newtio.c_cc[VTIME] = 0;
	newtio.c_cc[VMIN] = 0;
	/*处理未接收字符*/
	tcflush(fd,TCIFLUSH);
	/*激活新配置*/
	if((tcsetattr(fd,TCSANOW,&newtio))!=0)
	{
		perror("com set error");
		return -1;
	}
	printf("set done!\n");
	return 0;
}
Exemple #10
0
// コンストラクタ
Terminal::Terminal(QWidget *parent) : QMainWindow(parent), m_ds(this){
	// 変数初期化
	
	
	// GUIを作成
	m_ui.setupUi(this);

	// GUI各部の制御クラスを作成
	m_console = new TerminalConsole(m_ui.ConsoleInput, m_ui.ConsoleOutput, m_ui.ConsoleClear);
	m_info = new TerminalInfo(m_ui.StatusBar, m_ui.InfoIconDevice, m_ui.InfoLabelName, m_ui.InfoLabelVersion,
		m_ui.InfoButtonReboot, m_ui.InfoButtonConnect, m_ui.InfoButtonDisconnect);
	m_access = new TerminalAccess(m_ui.ProcessorInput, m_ui.ProcessorOpen, m_ui.ProcessorWrite, m_ui.ProcessorRead,
		m_ui.BitstreamInput, m_ui.BitstreamOpen, m_ui.BitstreamSend, m_ui.BitstreamWrite,
		m_ui.CoprocessorInput, m_ui.CoprocessorOpen, m_ui.CoprocessorSend, m_ui.CoprocessorWrite);
	m_controller = new TerminalController(this, m_ui.ControllerShow);
	m_logger = new TerminalLogger(m_ui.LoggerCheckUse, m_ui.LoggerGraph, m_ui.LoggerButtonAdd, m_ui.LoggerButtonRemove, m_ui.LoggerList, m_ui.LoggerSaveList,
		m_ui.LoggerLabel, m_ui.LoggerStart, m_ui.LoggerStop, m_ui.LoggerSave);
	m_pipe = new TerminalPipe(m_ui.PipeTable);
	m_file = new TerminalFile(m_ui.FileTree, m_ui.FileProgress);

	// ファイラータブのツールボックスにアイコンを設定
	QFileIconProvider icon_provider;
	m_ui.FilerToolBox->setItemIcon(0, icon_provider.icon(QFileIconProvider::Network));
	m_ui.FilerToolBox->setItemIcon(1, icon_provider.icon(QFileIconProvider::Drive));

	// 非同期操作用のスレッドを作成
	m_thread = new QThread(this);
	m_async = new TerminalAsync(&m_ds);
	m_async->moveToThread(m_thread);
	
	// シグナルを接続
	connect(&m_ds, SIGNAL(enableConsole(bool)), m_console, SLOT(enable(bool)));
	connect(&m_ds, SIGNAL(enableInfo(bool, bool)), m_info, SLOT(enable(bool, bool)));
	connect(&m_ds, SIGNAL(enableAccess(char, bool, bool, bool, bool)), m_access, SLOT(enable(char, bool, bool, bool, bool)));
	connect(&m_ds, SIGNAL(enableFileTree(bool, bool, bool, bool, bool, bool)), m_file, SLOT(enable(bool, bool, bool, bool, bool, bool)));
	connect(&m_ds, SIGNAL(enableController(bool, bool, bool)), m_controller, SLOT(enable(bool, bool, bool)));
	connect(&m_ds, SIGNAL(enableLogger(bool, bool, bool)), m_logger, SLOT(enable(bool, bool, bool)));

	connect(m_async, SIGNAL(showWarningConst(const wchar_t *, const wchar_t *)), this, SLOT(showWarningConst(const wchar_t *, const wchar_t *)), Qt::QueuedConnection);
	connect(m_async, SIGNAL(sendProgress(int)), m_info, SLOT(setProgress(int)), Qt::QueuedConnection);
	connect(m_async, SIGNAL(setExclusiveState(bool)), &m_ds, SLOT(setExclusiveState(bool)), Qt::QueuedConnection);
	connect(m_console, SIGNAL(send(const QString &)), this, SLOT(transmitDebug(const QString &)));
	connect(m_info, SIGNAL(changeConnection(const std::wstring *, bool, bool)), this, SLOT(changeConnection(const std::wstring *, bool, bool)));
	connect(m_info, SIGNAL(rebootRequest(const wchar_t *)), &m_ds, SLOT(changeBootMode(const wchar_t *)));
	connect(m_access, SIGNAL(operation(char, std::wstring *)), m_async, SLOT(onAccessOperation(char, std::wstring *)), Qt::QueuedConnection);
	//connect(m_controller, SIGNAL(operation(const Controller_t &)), &m_ds, SLOT(setController(const Controller_t &)));
	connect(m_file, SIGNAL(updateRequest(const std::wstring &)), m_ds.m_dsDir, SLOT(updateRequest(const std::wstring &)));
	connect(m_file, SIGNAL(moveRequest(const std::wstring &, const std::wstring &)), m_ds.m_dsDir, SLOT(moveRequest(const std::wstring &, const std::wstring &)));
	connect(m_file, SIGNAL(copyRequest(const std::wstring &, const std::wstring &)), m_ds.m_dsDir, SLOT(copyRequest(const std::wstring &, const std::wstring &)));
	connect(m_file, SIGNAL(deleteRequest(const std::wstring &)), m_ds.m_dsDir, SLOT(deleteRequest(const std::wstring &)));
	connect(m_file, SIGNAL(mkdirRequest(const std::wstring &)), m_ds.m_dsDir, SLOT(mkdirRequest(const std::wstring &)));
	connect(m_file, SIGNAL(transfarToDevice(std::wstring *, std::wstring *)), m_async, SLOT(transfarToDevice(std::wstring *, std::wstring *)), Qt::QueuedConnection);
	connect(m_file, SIGNAL(transfarFromDevice(std::wstring *, std::wstring *)), m_async, SLOT(transfarFromDevice(std::wstring *, std::wstring *)), Qt::QueuedConnection);
	connect(m_logger, SIGNAL(sendLoggingList(char *, unsigned int)), m_async, SLOT(setLoggingList(char *, unsigned int)), Qt::QueuedConnection);
	connect(m_async, SIGNAL(sendLog(unsigned short *, unsigned int)), m_logger, SLOT(receiveLog(unsigned short *, unsigned int)), Qt::QueuedConnection);
	connect(m_async, SIGNAL(sendLoggingError()), m_logger, SLOT(receiveError()), Qt::QueuedConnection);
	connect(m_controller, SIGNAL(setControllerState(ControllerState_t *)), m_async, SLOT(setControllerState(ControllerState_t *)), Qt::QueuedConnection);
	connect(m_async, SIGNAL(requestControllerState()), m_controller, SLOT(requestControllerState()), Qt::QueuedConnection);

	connect(&m_ds, SIGNAL(setDebugText(QString &)), m_info, SLOT(setDebugText(QString &)));
	connect(&m_ds, SIGNAL(sendProgress(int)), m_info, SLOT(setProgress(int)));
	connect(&m_ds, SIGNAL(setLogInfo(const std::wstring &)), m_logger, SLOT(setLogInfo(const std::wstring &)));
	connect(&m_ds, SIGNAL(changeConnection(const std::wstring *, bool, bool)), this, SLOT(changeConnection(const std::wstring *, bool, bool)));
	connect(&m_ds, SIGNAL(updateWidgetsInfo()), this, SLOT(updateWidgetsInfo()));
	
	connect(m_ds.m_dsPipe, SIGNAL(clearPipe()), m_pipe, SLOT(clearPipe()));
	connect(m_ds.m_dsPipe, SIGNAL(addPipe(const wchar_t *, int, int, const wchar_t *)), m_pipe, SLOT(addPipe(const wchar_t *, int, int, const wchar_t *)));
	connect(m_ds.m_dsDir, SIGNAL(initTree(const std::wstring &)), m_file, SLOT(initTree(const std::wstring &)));
	connect(m_ds.m_dsDir, SIGNAL(addDrive(char, const std::wstring &, bool, unsigned long long)), m_file, SLOT(addDrive(char, const std::wstring &, bool, unsigned long long)));
	connect(m_ds.m_dsDir, SIGNAL(changeDriveStatus(char, unsigned long long)), m_file, SLOT(changeDriveStatus(char, unsigned long long)));
	connect(m_ds.m_dsDir, SIGNAL(moveToItem(const std::wstring &)), m_file, SLOT(moveToItem(const std::wstring &)));
	connect(m_ds.m_dsDir, SIGNAL(addItem(const std::wstring &, unsigned long long, bool, unsigned int)), m_file, SLOT(addItem(const std::wstring &, unsigned long long, bool, unsigned int)));
	connect(m_ds.m_dsDir, SIGNAL(moveUp()), m_file, SLOT(moveUp()));
	connect(m_ds.m_dsFile, SIGNAL(changeFile(std::wstring *, unsigned long long)), m_file, SLOT(changeFile(std::wstring *, unsigned long long)), Qt::QueuedConnection);

	





	

	// タイマーを作成
	QTimer *interval = new QTimer(this);
    connect(interval, SIGNAL(timeout()), this, SLOT(onInterval()));
	connect(interval, SIGNAL(timeout()), m_logger, SLOT(update()));
    interval->start(PERIOD);

	// ウィジェットを初期状態に
	m_console->enable(false);
	m_info->enable(false, false);
	m_access->enable('P', false);
	m_access->enable('B', false);
	m_access->enable('C', false);
	m_file->enable(false);
	m_controller->enable(false);
	m_logger->enable(false);

	// 前回の設定の読み込み
	int maximized = 0;
	clINI setting;
	if (setting.Open(g_ApplicationDir.c_str(), L"setting.ini") == true){
		// パスの読み込み
		wchar_t buf[MAX_PATH];
		setting.Read(L"Path", L"Processor", buf);
		m_access->setPath('P', buf);
		setting.Read(L"Path", L"Bitstream", buf);
		m_access->setPath('B', buf);
		setting.Read(L"Path", L"Coprocessor", buf);
		m_access->setPath('C', buf);

		// 設定の読み込み
		int baudrate = m_info->getBaudrate();
		setting.Read(L"Setting", L"Baudrate", baudrate);
		m_info->setBaudrate(baudrate);

		// ウィンドウ座標・サイズの読み込み
		int pos_x, pos_y, size_w, size_h;
		setting.Read(L"Window", L"Maximize", maximized);
		setting.Read(L"Window", L"PosX", pos_x);
		setting.Read(L"Window", L"PosY", pos_y);
		setting.Read(L"Window", L"SizeW", size_w);
		setting.Read(L"Window", L"SizeH", size_h);
		pos_x -= 500000;
		pos_y -= 500000;
		size_w -= 500000;
		size_h -= 500000;
		if ((abs(pos_x) <= 32767) && (abs(pos_y) <= 32767)) this->move(pos_x, pos_y);
		if ((abs(size_w) <= 32767) && (abs(size_h) <= 32767)) this->resize(size_w, size_h);
	}

	// 非同期操作用スレッドを開始
	m_thread->start();

	// タイマーの精度を高める
	timeBeginPeriod(1);

	// ウィンドウを表示
	if (maximized == 0){
		this->show();
	}else{
		this->showMaximized();
	}
}
Exemple #11
0
/* 
 * Class:     cedric_serial_SerialPort 
 * Method:    open 
 * Signature: (Ljava/lang/String;)V 
 */  
JNIEXPORT jobject JNICALL Java_com_erobbing_mcutool_SerialPort_open(JNIEnv *env, jobject thiz, jstring path,jint baudrate) {  
    int fd;  
    speed_t speed;  
    jobject mFileDescriptor;  
  
    LOGD("init native Check arguments");  
    /* Check arguments */  
    {  
        speed = getBaudrate(baudrate);  
        if (speed == -1) {  
            /* TODO: throw an exception */  
            LOGE("Invalid baudrate");  
            return NULL;  
        }  
    }  
  
    LOGD("init native Opening device!");  
    /* Opening device */  
    {  
        jboolean iscopy;  
        const char *path_utf = env->GetStringUTFChars(path, &iscopy);  
        LOGD("Opening serial port %s", path_utf);  
//      fd = open(path_utf, O_RDWR | O_DIRECT | O_SYNC);  
        fd = open(path_utf, O_RDWR | O_NOCTTY | O_NONBLOCK | O_NDELAY);  
        LOGD("open() fd = %d", fd);  
        env->ReleaseStringUTFChars(path, path_utf);  
        if (fd == -1) {  
            /* Throw an exception */  
            LOGE("Cannot open port %d",baudrate);  
            /* TODO: throw an exception */  
            return NULL;  
        }  
    }  
  
    LOGD("init native Configure device!");  
    /* Configure device */  
    {  
        struct termios cfg;  
        if (tcgetattr(fd, &cfg)) {  
            LOGE("Configure device tcgetattr() failed 1");  
            close(fd);  
            return NULL;  
        }  
  
        cfmakeraw(&cfg);  
        cfsetispeed(&cfg, speed);  
        cfsetospeed(&cfg, speed);  
  
        if (tcsetattr(fd, TCSANOW, &cfg)) {  
            LOGE("Configure device tcsetattr() failed 2");  
            close(fd);  
            /* TODO: throw an exception */  
            return NULL;  
        }  
    }  
  
    /* Create a corresponding file descriptor */  
    {  
        jclass cFileDescriptor = env->FindClass("java/io/FileDescriptor");  
        jmethodID iFileDescriptor = env->GetMethodID(cFileDescriptor,"<init>", "()V");  
        jfieldID descriptorID = env->GetFieldID(cFileDescriptor,"descriptor", "I");  
        mFileDescriptor = env->NewObject(cFileDescriptor,iFileDescriptor);  
        env->SetIntField(mFileDescriptor, descriptorID, (jint) fd);  
    }  
  
    return mFileDescriptor;  
}  
Exemple #12
0
// Opens the connection to the GPS. All old messages in the queue are removed.
bool GpsClient::openGps( const char *deviceIn, const uint ioSpeedIn )
{
    // qDebug() << "GpsClient::openGps:" << deviceIn << "," << ioSpeedIn;

    device          = deviceIn;
    ioSpeedDevice   = ioSpeedIn;
    ioSpeedTerminal = getBaudrate(ioSpeedIn);
    badSentences    = 0;
    unknownsReported.clear();

    if( deviceIn == (const char *) 0 || strlen(deviceIn) == 0 )
    {
        // no valid device has been passed
        return false;
    }

    // reset buffer pointer
    datapointer = databuffer;
    dbsize      = 0;
    memset( databuffer, 0, sizeof(databuffer) );

    if( fd != -1 )
    {
        // closes an existing connection before opening a new one
        closeGps();
        sleep(2);
    }

#ifdef BLUEZ

    // Define a reg. expression for a Bluetooth address like "XX:XX:XX:XX:XX:XX"
    QRegExp regExp("([0-9A-Fa-f]{2,2}:){5,5}[0-9A-Fa-f]{2,2}");

    if( QString(deviceIn).contains(QRegExp( regExp )) )
    {
        fd = socket( AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM );

        // NON blocking io is requested!
        fcntl( fd, F_SETFL, O_NONBLOCK );

        struct sockaddr_rc addr;

        memset( &addr, 0, sizeof (addr) );

        addr.rc_family = AF_BLUETOOTH;

        // 1 is the default channel for a connection to the BT daemon
        addr.rc_channel = (uint8_t) 1;
        str2ba( deviceIn, &addr.rc_bdaddr );

        if( connect( fd, (struct sockaddr *) &addr, sizeof (addr)) == -1 &&
                errno != EINPROGRESS )
        {
            qCritical() << "GpsClient::openGps(): BT connect error"
                        << errno << "," << strerror(errno);

            close( fd );
            fd = -1;

            last = QTime();
            setShutdownFlag(true);
            return false;
        }

        // Stop supervision control to give the BT daemon time for connection.
        // The first data read will activate it again.
        last = QTime();
        return true;
    }

#endif

    // create a fifo for the nmea simulator, if device starts not with /dev/
    if( strncmp( "/dev/", deviceIn, strlen("/dev/") ) != 0 )
    {
        int ret = mkfifo( device.data(), S_IRUSR | S_IWUSR );

        if( ret && errno != EEXIST )
        {
            perror("mkfifo");
        }
    }

    fd = open( device.data(), O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK );

    if( fd == -1 )
    {
        perror( "Open GPS device:" );

        // Could not open the serial device.
#ifdef ERROR_LOG
        qWarning() << "openGps: Unable to open GPS device"
                   << device << "at transfer rate"
                   << ioSpeedIn;
#endif

        last.start(); // store time point for restart control
        return false;
    }

    if( ! isatty(fd) )
    {
        // Fifo needs no serial initialization.
        // Write a notice for the user about that fact
        if( device.startsWith("/dev/") )
        {
            qDebug() << "GpsClient::openGps: Device '"
                     << deviceIn
                     << "' is not a TTY!";
        }
    }
    else
    {
        tcgetattr(fd, &oldtio); // get current options from port

        // copy current values into new structure for changes
        memcpy( &newtio, &oldtio, sizeof(newtio) );

        // http://www.mkssoftware.com/docs/man5/struct_termios.5.asp
        //
        // Prepare serial port settings for raw mode. That is important
        // otherwise Flarm binary communication do not work!
        //
        // - no canonical input (no line oriented input)
        // - 8 data bits
        // - no parity
        // - no interpretation of special characters
        // - no hardware control

        // Port control modes
        // CS8    8 bits per byte
        // CLOCAL Ignore modem status lines
        // CREAD  Enable receiver
        newtio.c_cflag = CS8 | CLOCAL | CREAD;

        // Port input modes
        // raw input without any special handling
        newtio.c_iflag = 0;

        // Port output modes
        // raw output without any special handling
        newtio.c_oflag = 0;

        // Port local modes
        // raw input/output without any special handling
        newtio.c_lflag = 0;

        // The values of the MIN and TIME members of the c_cc array of the termios
        // structure are used to determine how to process the bytes received.
        //
        // MIN represents the minimum number of bytes that should be received when
        // the read() function returns successfully.
        //
        // TIME is a timer of 0.1 second granularity (or as close to that value as
        // can be accommodated) that is used to time out bursty and short-term data
        // transmissions.
        newtio.c_cc[VMIN]  = 1;
        newtio.c_cc[VTIME] = 0;

        // AP: Note, the setting of the speed must be done at last
        // because the manipulation of the c_iflag and c_oflag can
        // destroy the already assigned values! Needed me several hours
        // to find out that. Setting the baud rate under c_cflag seems
        // also to work.
        cfsetispeed( &newtio, ioSpeedTerminal ); // set baud rate for input
        cfsetospeed( &newtio, ioSpeedTerminal ); // set baud rate for output

        tcflush(fd, TCIOFLUSH);
        tcsetattr(fd, TCSANOW, &newtio);

        fcntl(fd, F_SETFL, FNDELAY); // NON blocking io is requested
    }

    last.start(); // store time point for supervision control
    return true;
}