void getDevices( std::vector<pollfd> &deviceFds ) { DIR * dir; struct dirent *result; char *devPathName; int devNum; if ( NULL != (dir = opendir( inputPath )) ) { while( NULL != (result = readdir( dir )) ) { int len= strlen( result->d_name ); if ( (len >= 5) && !strncmp(result->d_name, "event", 5) ) { if ( sscanf( result->d_name, "event%d", &devNum ) == 1 ) { printf(" [%s] ", result->d_name); devPathName= getDevice( inputPath, result->d_name ); if ( devPathName ) { openDevice( deviceFds, devPathName ); free( devPathName ); } } } } closedir( dir ); } }
int main(int argc, char *argv[]){ pthread_t monitor; int file; if(argc != 2){ printf("Usage is: lidar <device file>\n"); goto error; } file = openDevice(argv[1]); if(file < 0){ printf("error opening file\n"); goto error; } signal(SIGUSR1, danger); signal(SIGINT, quit); keepChecking = 1; pthread_create(&monitor, NULL, (void*) &monitorDistance, (void*) &file); pthread_join(monitor, NULL); close(file); error: return 0; }
void TICC1100::initDevice() { try { openDevice(); if(!_fileDescriptor || _fileDescriptor->descriptor == -1) return; initChip(); _out.printDebug("Debug: CC1100: Setting GPIO direction"); setGPIODirection(1, GPIODirection::IN); _out.printDebug("Debug: CC1100: Setting GPIO edge"); setGPIOEdge(1, GPIOEdge::BOTH); openGPIO(1, true); if(!_gpioDescriptors[1] || _gpioDescriptors[1]->descriptor == -1) throw(BaseLib::Exception("Couldn't listen to rf device, because the gpio pointer is not valid: " + _settings->device)); if(gpioDefined(2)) //Enable high gain mode { openGPIO(2, false); if(!getGPIO(2)) setGPIO(2, true); closeGPIO(2); } } catch(const std::exception& ex) { _out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what()); } catch(BaseLib::Exception& ex) { _out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what()); } catch(...) { _out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__); } }
int main(int argc, char ** argv) { checkIfSudo(); int vFlag = 0; char *iFlag = NULL; char *oFlag = NULL; char *fFlag = NULL; char *errbuf = malloc(PCAP_ERRBUF_SIZE); pcap_t *handle = NULL; struct bpf_program fp; bpf_u_int32 net = 0; /* The IP of our sniffing device */ getOptions(argc, argv, &vFlag, &iFlag, &oFlag, &fFlag); if(iFlag != NULL) { printf("****LIVEMODE****\n"); printf("\n"); openDevice((u_char*) &fFlag ,&iFlag, &handle, &errbuf); pcap_loop(handle, -1 , got_packet, (u_char*) &vFlag); } else { printf("*****OFFLINE MODE*****\n"); printf("\n"); openOfflineDevice(oFlag, &handle, &errbuf); pcap_loop(handle, -1 , got_packet, (u_char*) &vFlag); } signal(SIGINT,ctrl_c); pcap_close(handle); return 0; }
// Helper function, perform a sanity check on the device MediaError MythCDROMFreeBSD::testMedia() { //cout << "MythCDROMLinux::testMedia - "; bool OpenedHere = false; if (!isDeviceOpen()) { //cout << "Device is not open - "; if (!openDevice()) { //cout << "failed to open device - "; if (errno == EBUSY) { //cout << "errno == EBUSY" << endl; return isMounted(true) ? MEDIAERR_OK : MEDIAERR_FAILED; } else { return MEDIAERR_FAILED; } } //cout << "Opened it - "; OpenedHere = true; } // Be nice and close the device if we opened it, otherwise it might be locked when the user doesn't want it to be. if (OpenedHere) closeDevice(); return MEDIAERR_OK; }
int COM_Init (int *fd_atcmd, int *fd_uart, int *hUsbComPort) { *fd_atcmd = openDevice(); if(*fd_atcmd == -1) { LOGE(TAG "Open ccci port fail\r\n" ); return *fd_atcmd; } //ATE Tool use 115200 baud rate *fd_uart = open_uart_port(UART_PORT1, 115200, 8, 'N', 1); if(*fd_uart == -1) { LOGE(TAG "Open uart port %d fail\r\n" ,UART_PORT1); return *fd_uart; } else LOGD(TAG "Open uart port %d success\r\n" ,UART_PORT1); //*hUsbComPort = open("/dev/ttyGS0",O_RDWR | O_NOCTTY | /*O_NONBLOCK | */O_NDELAY); *hUsbComPort = open_usb_port(UART_PORT1, 115200, 8, 'N', 1); if(*hUsbComPort == -1) { LOGE(TAG "Open usb fail\r\n"); return *hUsbComPort; } else { //initTermIO(*hUsbComPort); LOGD(TAG "Open usb success\r\n"); } return 0; }
int InputDriverAbstract::initialize() { int ret; ret = openDevice(); if (ret < 0) { finalize(); return ret; } ret = guessDeviceType(); if (ret < 0) { finalize(); return ret; } ret = initMapping(); if (ret < 0) { finalize(); return ret; } ret = validate(); if (ret < 0) { finalize(); return ret; } return 0; }
//----------------------------------------------------------------------------- bool HIDDevice::OnDeviceNotification(MessageType messageType, HIDDeviceDesc* device_info, bool* error) { const char* device_path = device_info->Path.ToCStr(); if (messageType == Message_DeviceAdded && DeviceHandle < 0) { // Is this the correct device? if (!(device_info->VendorId == DevDesc.VendorId && device_info->ProductId == DevDesc.ProductId && device_info->SerialNumber == DevDesc.SerialNumber)) { return false; } // A closed device has been re-added. Try to reopen. if (!openDevice(device_path)) { LogError("OVR::Linux::HIDDevice - Failed to reopen a device '%s' that was re-added.\n", device_path); *error = true; return true; } LogText("OVR::Linux::HIDDevice - Reopened device '%s'\n", device_path); if (Handler) { Handler->OnDeviceMessage(HIDHandler::HIDDeviceMessage_DeviceAdded); } } else if (messageType == Message_DeviceRemoved) { // Is this the correct device? // For disconnected device, the device description will be invalid so // checking the path is the only way to match them if (DevDesc.Path.CompareNoCase(device_path) != 0) { return false; } if (DeviceHandle >= 0) { closeDevice(true); } if (Handler) { Handler->OnDeviceMessage(HIDHandler::HIDDeviceMessage_DeviceRemoved); } } else { OVR_ASSERT(0); } *error = false; return true; }
bool EepromDev::saveToDevice(void) { bool ret_value = false; int fd; if (openDevice(fd)) { const char *buffer = (const char *)&data_; unsigned int buffer_offset = 0; int page_size = data_.page_size; bool ret; while (buffer_offset < sizeof(data_)) { if ((buffer_offset + page_size) > sizeof(data_)) page_size = sizeof(data_) - buffer_offset; ret = writeI2C(fd, buffer_offset, (void *)(buffer + buffer_offset), page_size); if (!ret) { break; } buffer_offset += page_size; } ::close(fd); } else ret_value = -1; return ret_value; }
int main(int argc, char **argv) { usbDevice_t *dev; char buffer[4]; /* room for dummy report ID */ int err; if(argc < 2){ usage(argv[0]); exit(1); } if((dev = openDevice()) == NULL) exit(1); if(strcasecmp(argv[1], "read") == 0){ int len = sizeof(buffer); if((err = usbhidGetReport(dev, 0, buffer, &len)) != 0){ fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err)); }else{ hexdump(buffer + 1, sizeof(buffer) - 1); } }else if(strcasecmp(argv[1], "write") == 0){ int i, pos; memset(buffer, 0, sizeof(buffer)); for(pos = 1, i = 2; i < argc && pos < sizeof(buffer); i++){ pos += hexread(buffer + pos, argv[i], sizeof(buffer) - pos); } if((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */ fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err)); }else{ usage(argv[0]); exit(1); } usbhidCloseDevice(dev); return 0; }
/** * @brief 重置USB设备 */ bool USBControl::resetDevice() { CloseHandle(m_hDevice); bool status = openDevice(); return status; }
BOOL initDialog(HWND hWnd) { HICON hIcon; TC_ITEM tci; int i; hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_APP_ICON)); SendMessage(hWnd, WM_SETICON, (LPARAM) ICON_BIG, (WPARAM) hIcon); hURLFont = 0; hWndTab = GetDlgItem(hWnd,IDC_TAB); ZeroMemory(&tci, sizeof(TC_ITEM)); tci.mask = TCIF_TEXT; for (i=0;i<NUM_TABS;i++) { tci.pszText = tabsName[i]; if (TabCtrl_InsertItem(hWndTab, i, &tci) == -1) { PrintLastError("TabCtrl_InsertItem()"); return FALSE; } hWndChild[i] = CreateDialogParam(hInst, MAKEINTRESOURCE(tabsResource[i]), hWndTab, (DLGPROC)TabDlgProc, 0); } hURLFont = CreateFont(20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, VARIABLE_PITCH | FF_SWISS, "MS Shell Dlg"); SendMessage(GetDlgItem(hWndChild[NUM_TABS-1], IDC_URL2), WM_SETFONT, (WPARAM)hURLFont, TRUE); currentTab = 0; ShowWindow(hWndChild[0], SW_SHOWDEFAULT); if (!openDevice(TRUE)) { PrintLastError("openDevice()"); return FALSE; } return setDlgItems(hWnd); }
MidiInput::MidiInput( const char* device, int nvoices ) { char tmpname[ 16 ]; running = 0; this->nvoices = nvoices; voices = new midi_voice[ nvoices ]; pthread_mutex_init(&startStopLock, NULL); lastNote = -1; if ( openDevice( device, MIDI_READ ) < 0 ) return; addOutput( "bend", false ); for( int i = 0; i < nvoices; i++ ) { voices[ i ].note = -1; sprintf(tmpname, "sig%d", i); voices[ i ].pitchOutput = addOutput(tmpname, false); sprintf(tmpname, "amp%d", i); voices[ i ].gateOutput = addOutput(tmpname, false); } }
bool HIDDevice::HIDInitialize(const String& path) { DevDesc.Path = path; if (!openDevice()) { LogText("OVR::OSX::HIDDevice - Failed to open HIDDevice: %s", path.ToCStr()); return false; } // Setup notification for when a device is unplugged and plugged back in. if (!setupDevicePluggedInNotification()) { LogText("OVR::OSX::HIDDevice - Failed to setup notification for when device plugged back in."); closeDevice(false); return false; } HIDManager->DevManager->pThread->AddTicksNotifier(this); LogText("OVR::OSX::HIDDevice - Opened '%s'\n" " Manufacturer:'%s' Product:'%s' Serial#:'%s'\n", DevDesc.Path.ToCStr(), DevDesc.Manufacturer.ToCStr(), DevDesc.Product.ToCStr(), DevDesc.SerialNumber.ToCStr()); return true; }
// Helper function, perform a sanity check on the device MythMediaError MythCDROMFreeBSD::testMedia() { bool OpenedHere = false; if (!isDeviceOpen()) { if (!openDevice()) { if (errno == EBUSY) { return isMounted() ? MEDIAERR_OK : MEDIAERR_FAILED; } else { return MEDIAERR_FAILED; } } OpenedHere = true; } // Be nice and close the device if we opened it, otherwise it might be locked when the user doesn't want it to be. if (OpenedHere) closeDevice(); return MEDIAERR_OK; }
void CVFD::setlcdparameter(int dimm, const int power) { if(!has_lcd) return; if(dimm < 0) dimm = 0; else if(dimm > 15) dimm = 15; if(!power) dimm = 0; if(brightness == dimm) return; brightness = dimm; printf("CVFD::setlcdparameter dimm %d power %d\n", dimm, power); #ifdef __sh__ openDevice(); struct vfd_ioctl_data data; data.start_address = dimm; int ret = ioctl(fd, VFDBRIGHTNESS, &data); closeDevice(); #else int ret = ioctl(fd, IOC_VFD_SET_BRIGHT, dimm); if(ret < 0) perror("IOC_VFD_SET_BRIGHT"); #endif }
int main(int argc, char **argv) { if (argc >= 3) { float freq = strtof(argv[1], NULL); float bandwidth = strtof(argv[2], NULL); int decimation = atoi(argv[3]); std::cout << "Frequency: " << freq << "\n"; std::cout << "Bandwidth " << bandwidth << "\n"; std::cout << "Decimation " << decimation << "\n"; std::cout << "Opening Signalhound SA device\n"; int id = openDevice(); startIQ(id, freq, bandwidth, decimation); // startIQ(id, 915.0e6, 50.0e3, 8); closeDevice(id); } else { std::cout << "Stream IQ pairs at a particualar frequency\n"; std::cout << "Usage:\n"; std::cout << "signalhoundiq frequency bandwidth [decimation]\n"; std::cout << "Frequency in Hz\n"; std::cout << "Bandwidth in Hz\n"; std::cout << "Decimation 1-16 (default 8)\n"; } return 0; }
/************************************************************************************** Function Name : main Description : Read and Write the Password in the EEPROM Parameters : commandline arguments Return : NULL **************************************************************************************/ int main(int argc, char **argv) { usbDevice_t *dev; char buffer[129]; /* room for dummy report ID */ int err; if(argc < 2){ usage(argv[0]); exit(1); } if((dev = openDevice()) == NULL) exit(1); if(strcasecmp(argv[1], "read") == 0){ int len = sizeof(buffer); if((err = usbhidGetReport(dev, 0, buffer, &len)) != 0){ fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err)); }else{ hexdump(buffer + 1, sizeof(buffer) - 1); } }else if(strcasecmp(argv[1], "write") == 0){ memset(buffer, 0, sizeof(buffer)); int i = 1; while(*argv[2] != '\0'){ buffer[i] += *argv[2]++; i++; } if((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */ fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err)); }else{ usage(argv[0]); exit(1); } usbhidCloseDevice(dev); return 0; }
void NewSerialDeviceDialog::setupUI() { this->setWindowTitle("Open serial port"); QVBoxLayout* layout = new QVBoxLayout(); QDialogButtonBox* buttons = new QDialogButtonBox(QDialogButtonBox::Open | QDialogButtonBox::Cancel, Qt::Horizontal, this); connect(buttons, SIGNAL(accepted()), this, SLOT(openDevice())); connect(buttons, SIGNAL(rejected()), this, SLOT(reject())); QFormLayout* form = new QFormLayout(); form->addRow("Device", device = new QComboBox(this)); form->addRow("Baudrate", baudrate = new QComboBox(this)); form->addRow("Parity", parity = new QComboBox(this)); form->addRow("Data Bits", dataBits = new QComboBox(this)); form->addRow("Stop Bits", stopBits = new QComboBox(this)); form->addRow("Flow Control", flowControl = new QComboBox(this)); form->addRow("Read Only", readOnly = new QCheckBox(this)); layout->addLayout(form, 80); layout->addWidget(buttons, 20, Qt::AlignBottom); setLayout(layout); //update data Q_FOREACH(QSerialPortInfo info, QSerialPortInfo::availablePorts()) { this->device->addItem(info.portName(), QVariant::fromValue(info)); }
/* player thread; for every song a new thread is started * @param audioPlayer structure * @return PLAYER_RET_* */ void *BarPlayerThread (void *data) { assert (data != NULL); player_t * const player = data; uintptr_t pret = PLAYER_RET_OK; bool retry; do { retry = false; if (openStream (player)) { if (openFilter (player) && openDevice (player)) { player->mode = PLAYER_PLAYING; BarPlayerSetVolume (player); retry = play (player) == AVERROR_INVALIDDATA && !player->interrupted; } else { /* filter missing or audio device busy */ pret = PLAYER_RET_HARDFAIL; } } else { /* stream not found */ pret = PLAYER_RET_SOFTFAIL; } player->mode = PLAYER_WAITING; finish (player); } while (retry); player->mode = PLAYER_FINISHED; return (void *) pret; }
/* ------------------------------------------------------------------------- */ usb_dev_handle* hidtool_open(void){ usb_dev_handle *dev; if((dev = openDevice()) == NULL){ fprintf(stderr, "Can not open device.\n"); exit(1); } return dev; }
cAudio::cAudio(void *, void *, void *) { fd = -1; clipfd = -1; mixer_fd = -1; openDevice(); Muted = false; }
int USBLink::open() { close(); libusb_init(&m_context); return openDevice(); }
int usb_open( t_usbInterface* usbInt ) { //--------------------------------------- Mac-only ------------------------------- #ifndef WIN32 if( usbInt->deviceOpen ) //if it's already open, do nothing. return MC_ALREADY_OPEN; int result = FindUsbSerialDevice( &usbInt->deviceName, 0 ); //if( result ); //should return 0 on success //return; // now try to actually do something usbInt->deviceHandle = open( usbInt->deviceName, O_RDWR | O_NOCTTY | ( ( usbInt->blocking ) ? 0 : O_NDELAY ) ); if ( usbInt->deviceHandle < 0 ) { //post( "Could not open the port (Error %d)\n", usbInt->deviceHandle ); return MC_NOT_OPEN; } else { usbInt->deviceOpen = true; usleep( 10000 ); //give it a moment after opening before trying to read/write //post( "USB opened at %s, deviceHandle = %d", usbInt->deviceName, usbInt->deviceHandle); post( "mc.usb opened." ); } return MC_OK; #endif //--------------------------------------- Windows-only ------------------------------- #ifdef WIN32 TCHAR* openPorts[32]; int i; int foundOpen; if( usbInt->deviceOpen ) //if it's already open, do nothing. return MC_ALREADY_OPEN; foundOpen = ScanEnumTree( usbInt, TEXT("SYSTEM\\CURRENTCONTROLSET\\ENUM\\USB"), openPorts); //post( "Found %d ports open", foundOpen ); for( i = 0; i < foundOpen; i++ ) { if( openPorts[i] != NULL ) { if( openDevice( usbInt, openPorts[i] ) == 0 ) { post( "mc.usb opened at: %s", openPorts[i] ); Sleep( 10 ); // wait after opening it before trying to read/write usbInt->deviceOpen = true; return MC_OK; } } } //post( "mc.usb did not open." ); return MC_NOT_OPEN; #endif }
Device* DeviceManager::getAnyDevice() { Device* pDevice = getCurrentDevice(); if (pDevice == NULL) { openDevice(); pDevice = getCurrentDevice(); } return pDevice; }
BlockDevice(const std::string& name, const Mode mode, bool isDirect) : name_(name) , mode_(mode) , fd_(openDevice(name, mode, isDirect)) , deviceSize_(getDeviceSizeFirst()) { #if 0 ::printf("device %s size %zu mode %d isDirect %d\n", name_.c_str(), size_, mode_, isDirect_); #endif }
void V4L::init(const CameraProps & props) { dev_name = "/dev/" + props.device; if (openDevice()) { getDeviceCapabilities(); getVideoProperty(0); getBufferSize(); } else LOG(LERROR) << "function: V4L\n"; }
MythMediaError MythCDROMFreeBSD::eject(bool open_close) { if (!isDeviceOpen()) openDevice(); if (open_close) return (ioctl(m_DeviceHandle, CDIOCEJECT) == 0) ? MEDIAERR_OK : MEDIAERR_FAILED; else return MEDIAERR_UNSUPPORTED; }
int V4L2JpegEncoder::run(void) { int ret; sp<Buffer> thumbData; sp<Buffer> exifData; TRACE(); ret = openDevice(); if (ret < 0) { ERR("Failed to open JPEG encoder device"); return -1; } if (thumbnail.allocation != 0) { ret = encodeImage(&thumbnail); if (ret >= 0) { V4L2Buffer *buf = output.allocation->getBuffer(0); thumbData = new Buffer(buf->getUsed(), buf->getAddress()); } } ret = encodeImage(&input); if (ret < 0) { ERR("Failed to encode JPEG image"); closeDevice(); return -1; } closeDevice(); uint32_t exifSize = EXIF_SIZE; if (thumbData != 0) exifSize += thumbData->getSize(); exifData = new Buffer(exifSize); if (exifData == 0 || !exifData->initCheck()) { ERR("Failed to allocate exif buffer"); return -1; } exifData->zero(); exifSize = buildExif(exifData, thumbData); V4L2Buffer *buf = output.allocation->getBuffer(0); char *addr = (char *)buf->getAddress(); memmove(addr + exifSize, addr, buf->getUsed()); memcpy(addr, addr + exifSize, 2); memcpy(addr + 2, exifData->getData(), exifSize); return buf->getUsed() + exifSize; }
/* Scan the available ports & populate the list. If one of the ports is the one that was last open, open it up. Otherwise, wait for the user to select one then open that one. */ bool UsbConsole::loadAndShow( ) { if(!portList->currentText().isEmpty()) openDevice(portList->currentText()); enumerate(); #ifndef Q_WS_WIN enumerateTimer.start(ENUM_FREQUENCY); // makes Windows unhappy...problem with enumerator #endif this->show(); return true; }