Exemplo n.º 1
0
bool PA::get_device_info(const int &idx, PADeviceInfo &info)
{
	int num = get_device_count();
	if (idx < 0 || num <= idx) {
		printf("error : PA::get_device_info() : out of index...idx=", idx);
		return false;
	}

	info.set_device_idx_(idx);

	return true;
}
Exemplo n.º 2
0
std::vector<PADeviceInfo> PA::get_device_infos()
{
	int num = get_device_count();

	std::vector<PADeviceInfo> infos;
	for (int i = 0; i < num; ++i) {
		PADeviceInfo info;
		if (get_device_info(i, info)) {
			infos.push_back(info);
		}
	}

	return infos;
}
Exemplo n.º 3
0
bool PA::open_output(const int &dev_idx, const int &channels, const int &sampling_rate, const int &buf_size)
{
	PaError err;
	PaStreamParameters output_param;

	if (is_open()) return false;

	if (dev_idx < 0 || get_device_count() <= dev_idx) {
		printf("error :  PA::open_output() : out of index...dev_idx=%d", dev_idx);
		return false;
	}

	output_param.device = dev_idx;
	output_param.channelCount = channels;
	output_param.sampleFormat = paFloat32;
	output_param.suggestedLatency = Pa_GetDeviceInfo(output_param.device)->defaultLowOutputLatency;
	output_param.hostApiSpecificStreamInfo = NULL;

	err = Pa_OpenStream(
		&stream_,
		NULL,
		&output_param,
		sampling_rate,
		buf_size,  // frames_per_buffer
		paClipOff,
		play_callback_,
		this);

	if (err != paNoError) {
		printf("error :  PA::open_output() : Pa_OpenStream() failed...dev_idx=%d", dev_idx);
		close();
		return false;
	}

	err = Pa_StartStream(stream_);
	if (err != paNoError) {
		printf("error :  PA::open_output() : Pa_StartStream() failed...dev_idx=%d", dev_idx);
		close();
		return false;
	}

	stream_type_ = PA_STREAM_TYPE_OUTPUT;
	output_device_idx_ = dev_idx;
	channels_ = channels;

	PADeviceInfo info = output_device_info();
	printf("PA::open_output() : open device...dev_idx=%d, name=%s\n", output_device_idx_, info.name().c_str());

	return true;
}
Exemplo n.º 4
0
		// Costructor with specific cl_platform_id
		platform(cl_platform_id m_platform_id)
		{

			// Initialise the clog object
			m_log = clog::getInstance();

			this->m_platform_id = m_platform_id;

			//std::cout << "The platform name is " << name().c_str() << std::endl;
			//std::cout << "The platform version is " << version().c_str() << std::endl;
			m_log->write("The platform name is ");
			m_log->write(name().c_str());
			m_log->write("\n");

			m_log->write("	The platform version is ");
			m_log->write(version().c_str());
			m_log->write("\n");

			m_devices_count = get_device_count();

			create_devices();
		}
Exemplo n.º 5
0
Arquivo: usb.c Projeto: seec/TL866
void *notifier_function()
{

    struct udev *udev;
    struct udev_monitor *mon;
    struct udev_device *dev;
    cancel = FALSE;
    const GUID guid = {0x85980D83,0x32B9,0x4BA1,{0x8F,0xDF,0x12,0xA7,0x11,0xB9,0x9C,0xA2}};
    DEV_BROADCAST_DEVICEINTERFACE_W DevBi;
    DevBi.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE_W);
    DevBi.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
    DevBi.dbcc_classguid = guid;

    udev = udev_new();
    if (!udev) {
        printf("Can't create udev\n");
        return;
    }


    mon = udev_monitor_new_from_netlink(udev, "udev");
    if(!mon)
    {
        printf("NetLink not available!\n");
        return;
    }
    int count = get_device_count();
    if(count == -1)
    {
        printf("udev error.\n");
        return;
    }

    udev_monitor_filter_add_match_subsystem_devtype(mon, "usb", NULL);
    udev_monitor_enable_receiving(mon);
    int fd = udev_monitor_get_fd(mon);

    while (!cancel) {
        fd_set fds;
        struct timeval tv;
        int ret;

        FD_ZERO(&fds);
        FD_SET(fd, &fds);
        tv.tv_sec = 0;
        tv.tv_usec = 0;

        ret = select(fd+1, &fds, NULL, NULL, &tv);
        if (ret > 0 && FD_ISSET(fd, &fds)) {

            dev = udev_monitor_receive_device(mon);
            if(dev && !strcmp(udev_device_get_devtype(dev),"usb_device")){
                int count_new;
                if(!strcmp(udev_device_get_action(dev), "add"))
                {
                    count_new = get_device_count();
                    if(count != count_new)
                    {
                        count = count_new;
                        //printf("device added.\n");
                        close_devices();
                        usleep(100000);
                        SendMessageW(hWnd, WM_DEVICECHANGE, DBT_DEVICEARRIVAL, (LPARAM)&DevBi);
                        RedrawWindow(hWnd, NULL, NULL, RDW_INVALIDATE);
                    }

                }
                else if(!strcmp(udev_device_get_action(dev), "remove"))
                {
                    count_new = get_device_count();
                    if(count != count_new)
                    {
                        count = count_new;
                        //printf("device removed.\n");
                        close_devices();
                        usleep(100000);
                        SendMessageW(hWnd, WM_DEVICECHANGE, DBT_DEVICEREMOVECOMPLETE, (LPARAM)&DevBi);
                        RedrawWindow(hWnd, NULL, NULL, RDW_INVALIDATE);
                    }
                }
                udev_device_unref(dev);
            }
        }
        usleep(10000);
    }
}
Exemplo n.º 6
0
int device::get_all_devices() {
	int num_devices = get_device_count();
	return num_devices;
}
Exemplo n.º 7
0
void menu_setup_devices()
{

	if(redraw)
	{
		clearDisplay();
		clear_buttons();
		redraw=0;

		draw_filledRect(0,0,LCD_WIDTH,35,155,100,100);

		draw_filledCircle(17,17,15,40,80,40);
		draw_text_8x6(7,10,"Back",255,100,100);

		uint16_t text_width =  get_text_width_16pt("Setup Devices");

		draw_text_16pt((LCD_WIDTH-text_width)>>1,9, "Setup Devices", 200,200,255);


		init_lineitems();
		char buf[30];
		char buf2[30];
		draw_lineitem("","<new>");
		for(int i = 0; i < get_device_count();i++)
		{
			snprintf(buf,30,"%i",get_device(i)->base_address);
		
			char classname[30];
			if(get_device(i)->device_class_uuid == 0)
			{
				strncpy(classname,"<empty>",30);
			}
			else if(get_device_class_by_uuid(get_device(i)->device_class_uuid) == NULL)
			{
				strncpy(classname,"<missing>",30);
			}
			else
			{
				strncpy(classname,get_device_class_by_uuid(get_device(i)->device_class_uuid)->name,30);
			}

			snprintf(buf2,30,"%s - %s",classname,get_device(i)->name);
			draw_lineitem(buf,buf2);
		}

		draw_scrollbar();

		draw_button_h(257,45,52,42,"^",155,0,0,0,255,0);
		if((get_device_count()<10)&&(active_row==0))
		{
			draw_button_h(257,92,52,42,"Add",155,0,0,0,255,0);
		}
		if(active_row>0)
		{
			draw_button_h(257,92,52,42,"Edit",155,0,0,0,255,0);
			draw_button_h(257,139,52,42,"Delete",155,0,0,0,255,0);
		}
		draw_button_h(257,186,52,42,"v",155,0,0,0,255,0);
	}

	uint8_t field=0;
	uint16_t x;
	uint16_t y;
	if(check_button_press(&x,&y)==1)
	{
		if(y > 41)
		{
			field=1;

			if(y > 184)
			{
				field=4;
			}else if(y > 136)
			{
				field=3;
			}else if(y > 89)
			{
				field=2;
			}
		}
		else
		{
			if(x < 40)
			{
				redraw=1;
				set_current_execution(menu_setup);
			}
		}
		
		if(field == 1)
		{
			if(active_row > 0)
			{
				if(active_row==scroll_offset)
				{
					scroll_offset--;
				}

				active_row--;
			}
			redraw=1;
		}
		if(field == 4)
		{
			if(active_row < (get_device_count()))
			{
				active_row++;
				int drawline = active_row-scroll_offset; 
				if(drawline==10)
				{
					scroll_offset++;
				}
			}
			redraw=1;
		}
		if(field == 2)
		{
			redraw=1;
			if(active_row==0)
			{
				if(get_device_count()<50)
				{
					set_current_execution(menu_setup_devices_add);
				}
			}
			else
			{
				set_current_execution(menu_setup_devices_edit);
				set_device_to_edit(active_row-1);
			}
		}
		if(field == 3)
		{
			redraw=1;
			
			if(active_row > 0)
			{
				del_device(active_row-1);
				if(active_row==scroll_offset)
				{
					scroll_offset--;
				}
				active_row--;
			}

		}
	}
}
Exemplo n.º 8
0
bool PA::open_wire(const int &input_dev_idx, const int &output_dev_idx, const int &sampling_rate, const int &buf_size)
{
	PaError err;
	PaStreamParameters input_param;
	PaStreamParameters output_param;

	if (is_open()) return false;

	if (input_dev_idx < 0 || get_device_count() <= input_dev_idx) {
		printf("error :  PA::open_wire() : out of index...input_dev_idx=%d", input_dev_idx);
		return false;
	}
	if (output_dev_idx < 0 || get_device_count() <= output_dev_idx) {
		printf("error :  PA::open_wire() : out of index...output_dev_idx=%d", output_dev_idx);
		return false;
	}

	input_param.device = input_dev_idx;
	input_param.channelCount = 2;
	input_param.sampleFormat = paFloat32;
	input_param.suggestedLatency = Pa_GetDeviceInfo(input_param.device)->defaultLowInputLatency;
	input_param.hostApiSpecificStreamInfo = NULL;

	output_param.device = output_dev_idx;
	output_param.channelCount = 2;
	output_param.sampleFormat = paFloat32;
	output_param.suggestedLatency = Pa_GetDeviceInfo(output_param.device)->defaultLowInputLatency;
	output_param.hostApiSpecificStreamInfo = NULL;

	err = Pa_OpenStream(
		&stream_,
		&input_param,
		&output_param,
		sampling_rate,
		buf_size,  // frames_per_buffer
		paClipOff,
		wire_callback_,
		this);

	if (err != paNoError) {
		printf("error :  PA::open_wire() : Pa_OpenStream() failed...intput_dev_idx=%d, output_dev_idx=%d", input_dev_idx, output_dev_idx);
		close();
		return false;
	}

	err = Pa_StartStream(stream_);
	if (err != paNoError) {
		printf("error :  PA::open_wire() : Pa_StartStream() failed...intput_dev_idx=%d, output_dev_idx=%d", input_dev_idx, output_dev_idx);
		close();
		return false;
	}

	stream_type_ = PA_STREAM_TYPE_WIRE;
	input_device_idx_ = input_dev_idx;
	output_device_idx_ = output_dev_idx;
	channels_ = 2;

	PADeviceInfo in_info = this->input_device_info();
	PADeviceInfo out_info = this->output_device_info();
	printf("PA::open_input() : open device...input=%d:%s, output=%d:%s\n", 
		input_dev_idx, in_info.name().c_str(),
		output_dev_idx, out_info.name().c_str());

	return true;
}