本文整理汇总了C++中cyg_thread_create函数的典型用法代码示例。如果您正苦于以下问题：C++ cyg_thread_create函数的具体用法？C++ cyg_thread_create怎么用？C++ cyg_thread_create使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了cyg_thread_create函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: cyg_start
/* --------------------------------------------------------------------------
* cyg_start
*
* ARM entry function
*
* @param : void
* @return : void
* @see : start_thread
*
* ARM entry function, start thread.
* --------------------------------------------------------------------------
*/
void cyg_start(void)
{
#ifdef MVBPROJ_BASIC_INFO_SUPPORT
printf("\n\n\n\n\nMVB ARM monitor for T113 (build%04d)\n\n", MVB_BUILD_DEFINITION);
#endif // ifdef MVBPROJ_BASIC_INFO_SUPPORT
#ifdef MVBPROJ_LED_SUPPORT
mvb_arm_init_led(0);
#endif
cyg_thread_create(START_WORKTHREAD_PRI, start_thread, 0, "START ARM", &start_stack, STACK_SIZE, &start_thread_handle, &start_thread_data);
cyg_thread_resume(start_thread_handle);
cyg_scheduler_start();
}示例2: cyg_user_start
void
cyg_user_start(void)
{
// Create a main thread, so we can run the scheduler and have time 'pass'
cyg_thread_create(10, // Priority - just a number
tmain, // entry
0, // entry parameter
"timeout test", // Name
&stack[0], // Stack
STACK_SIZE, // Size
&thread_handle, // Handle
&thread_data // Thread data structure
);
cyg_thread_resume(thread_handle); // Start it
}示例3: cyg_start
externC void
cyg_start( void )
{
// Create a main thread, so we can run the scheduler and have time 'pass'
cyg_thread_create(10, // Priority - just a number
lcd_exercise, // entry
0, // entry parameter
"LCD_test_thread", // Name
&stack[0], // Stack
STACK_SIZE, // Size
&thread_handle, // Handle
&thread_data // Thread data structure
);
cyg_thread_resume(thread_handle); // Start it
cyg_scheduler_start();
} // cyg_package_start()示例4: simple_multi_thread
int simple_multi_thread(void)
{
NET_DATA_T netdata1, netdata2, netdata3, netdata4, netdata5, netdata6, netdata7;
netdata1.iport = 40;
netdata1.pbuf = (char*)NON_CACHE(g_RemoteNet_Buf1);
netdata2.iport = 41;
netdata2.pbuf = (char*)NON_CACHE(g_RemoteNet_Buf2);
netdata3.iport = 42;
netdata3.pbuf = (char*)NON_CACHE(g_RemoteNet_Buf3);
netdata4.iport = 43;
netdata4.pbuf = (char*)NON_CACHE(g_RemoteNet_Buf4);
netdata5.iport = 44;
netdata5.pbuf = (char*)NON_CACHE(g_RemoteNet_Buf5);
netdata6.iport = 45;
netdata6.pbuf = (char*)NON_CACHE(g_RemoteNet_Buf6);
netdata7.iport = 46;
netdata7.pbuf = (char*)NON_CACHE(g_RemoteNet_Buf7);
cyg_thread_create(THREAD_PRIORITY, &simple_tcpserver, (cyg_addrword_t)&netdata1, "simple_tcpserver1",
thread_stack1, STACK_SIZE, &thread_handle1, &thread1);
cyg_thread_create(THREAD_PRIORITY, &simple_tcpserver, (cyg_addrword_t)&netdata2, "simple_tcpserver2",
thread_stack2, STACK_SIZE, &thread_handle2, &thread2);
cyg_thread_create(THREAD_PRIORITY, &simple_tcpserver, (cyg_addrword_t)&netdata3, "simple_tcpserver3",
thread_stack3, STACK_SIZE, &thread_handle3, &thread3);
cyg_thread_create(THREAD_PRIORITY, &simple_tcpserver, (cyg_addrword_t)&netdata4, "simple_tcpserver4",
thread_stack4, STACK_SIZE, &thread_handle4, &thread4);
cyg_thread_create(THREAD_PRIORITY, &simple_tcpserver, (cyg_addrword_t)&netdata5, "simple_tcpserver5",
thread_stack5, STACK_SIZE, &thread_handle5, &thread5);
cyg_thread_create(THREAD_PRIORITY, &simple_tcpserver, (cyg_addrword_t)&netdata6, "simple_tcpserver6",
thread_stack6, STACK_SIZE, &thread_handle6, &thread6);
//cyg_thread_create(THREAD_PRIORITY, &simple_tcpserver, (cyg_addrword_t)&netdata7, "simple_tcpserver7",
// thread_stack7, STACK_SIZE, &thread_handle7, &thread7);
/*
cyg_thread_create(THREAD_PRIORITY, &simple_udpserver, (cyg_addrword_t)&netdata1, "simple_udpserver1",
thread_stack1, STACK_SIZE, &thread_handle1, &thread1);
cyg_thread_create(THREAD_PRIORITY, &simple_udpserver, (cyg_addrword_t)&netdata2, "simple_udpserver2",
thread_stack2, STACK_SIZE, &thread_handle2, &thread2);
cyg_thread_create(THREAD_PRIORITY, &simple_udpserver, (cyg_addrword_t)&netdata3, "simple_udpserver3",
thread_stack3, STACK_SIZE, &thread_handle3, &thread3);
*/
tbegin = cyg_current_time();
cyg_thread_resume(thread_handle1);
cyg_thread_resume(thread_handle2);
cyg_thread_resume(thread_handle3);
cyg_thread_resume(thread_handle4);
cyg_thread_resume(thread_handle5);
cyg_thread_resume(thread_handle6);
//cyg_thread_resume(thread_handle7);
while(1)
{
cyg_thread_delay(100000);
}
}示例5: cyg_start
externC void
cyg_start( void )
{
// Create a main thread, so we can run the scheduler and have time 'pass'
cyg_thread_create(10, // Priority - just a number
program_flash, // entry
1, // index
"program_thread", // Name
&stack[0], // Stack
STACK_SIZE, // Size
&thread_handle, // Handle
&thread_data // Thread data structure
);
cyg_thread_resume(thread_handle); // Start it
cyg_scheduler_start();
} // cyg_package_start()示例6: cyg_start
void
cyg_start(void)
{
CYG_TEST_INIT();
cyg_thread_create(10, // Priority - just a number
(cyg_thread_entry_t*)serial_test, // entry
0, //
"serial_thread", // Name
&stack[0], // Stack
CYGNUM_HAL_STACK_SIZE_TYPICAL, // Size
&thread_handle, // Handle
&thread_data // Thread data structure
);
cyg_thread_resume(thread_handle);
cyg_scheduler_start();
}示例7: cyg_user_start
void cyg_user_start(void)
{
CYG_TEST_INIT();
cyg_thread_create(
10, // Arbitrary priority
(cyg_thread_entry_t*) run_tests, // Thread entry point
0, //
"test_thread", // Thread name
&stack[0], // Stack
CYGNUM_HAL_STACK_SIZE_TYPICAL, // Stack size
&thread_handle, // Thread handle
&thread_data // Thread data structure
);
cyg_thread_resume(thread_handle);
cyg_scheduler_start();
}示例8: cyg_start
externC void
cyg_start( void )
{
// Create a main thread, so we can run the scheduler and have time 'pass'
cyg_thread_create(11, // Priority - just a number
audio_exercise, // entry
0, // initial parameter
"AUDIO_thread", // Name
&stack[0], // Stack
STACK_SIZE, // Size
&thread_handle, // Handle
&thread_data // Thread data structure
);
cyg_thread_resume(thread_handle); // Start it
// Let 'em fly...
cyg_scheduler_start();
} // cyg_package_start()示例9: cyg_start
void
cyg_start(void)
{
static struct test_params p;
// Create a main thread, so we can run the scheduler and have time 'pass'
cyg_thread_create(10, // Priority - just a number
net_test, // entry
(cyg_addrword_t)&p,// entry parameter
"Network test", // Name
&stack[0], // Stack
STACK_SIZE, // Size
&thread_handle, // Handle
&thread_data // Thread data structure
);
cyg_thread_resume(thread_handle); // Start it
cyg_scheduler_start();
}示例10: eapd_start
void
eapd_start(void)
{
if (!_eapd_pid ||
!oslib_waitpid(_eapd_pid, NULL)) {
cyg_thread_create(7,
(cyg_thread_entry_t *)eapd_main,
(cyg_addrword_t)NULL,
"EAPD",
eapd_main_stack,
sizeof(eapd_main_stack),
&eapd_main_hdl,
&eapd_thread);
cyg_thread_resume(eapd_main_hdl);
EAPD_PRINT("EAPD task started\n");
}
}示例11: cyg_start
void
cyg_start(void)
{
CYG_TEST_INIT();
// Create a main thread, so we can run the scheduler and have time 'pass'
cyg_thread_create(CYGPKG_NET_THREAD_PRIORITY-4,// Priority - just a number
net_test, // entry
0, // entry parameter
"Loopback ping test", // Name
&stack[0], // Stack
STACK_SIZE, // Size
&thread_handle, // Handle
&thread_data // Thread data structure
);
cyg_thread_resume(thread_handle); // Start it
cyg_scheduler_start();
}示例12: cyg_net_snmp_init
void
cyg_net_snmp_init(void)
{
// Create network background thread
cyg_thread_create(CYGPKG_NET_THREAD_PRIORITY+1, // Priority, just lower than the net
snmpdloop, // entry
0, // entry parameter
"snmpd", // Name
&netsnmp_stack[0], // Stack
STACK_SIZE, // Size
&netsnmp_thread_handle, // Handle
&netsnmp_thread_data // Thread data structure
);
cyg_thread_resume(netsnmp_thread_handle); // Start it
// Done
}示例13: startup
static void
startup(CYG_ADDRESS data)
{
cyg_ucount32 pdc_data_index;
struct _pdc_app_entry *pdc;
printf("SYSTEM INITIALIZATION in progress\n");
#ifdef USE_JFFS2
{
int res;
printf("... Mounting JFFS2 on \"/\"\n");
res = mount(CYGDAT_IO_FLASH_BLOCK_DEVICE_NAME_1, "/", "jffs2");
if (res < 0) {
printf("Mount \"/\" failed - res: %d\n", res);
}
chdir("/");
}
#endif
pdc_data_index = cyg_thread_new_data_index();
printf("data index = %d\n", pdc_data_index);
printf("Creating system threads\n");
for (pdc = __PDC_APP_TAB__; pdc != &__PDC_APP_TAB_END__; pdc++) {
printf("Creating %s thread\n", pdc->name);
cyg_thread_create(pdc->prio,
pdc->entry,
(cyg_addrword_t) pdc_data_index,
pdc->name,
(void *) pdc->stack, STACKSIZE,
&pdc->t, &pdc->t_obj);
}
printf("Starting threads\n");
for (pdc = __PDC_APP_TAB__; pdc != &__PDC_APP_TAB_END__; pdc++) {
printf("Starting %s\n", pdc->name);
cyg_thread_resume(pdc->t);
if (pdc->init) {
(pdc->init) (pdc_data_index);
}
}
printf("SYSTEM THREADS STARTED!\n");
}示例14: cyg_start
void
cyg_start(void)
{
CYG_TEST_INIT();
//
// open flexcan device driver
//
if (ENOERR != cyg_io_lookup("/dev/can0", &hDrvFlexCAN))
{
CYG_TEST_FAIL_FINISH("Error opening /dev/can0");
}
//
// setup CAN baudrate 250 KBaud
// We do not setup baud rate and use the default baud rate instead
/*
cyg_uint32 len;
cyg_can_info_t can_cfg;
can_cfg.baud = CYGNUM_CAN_KBAUD_250;
len = sizeof(can_cfg);
if (ENOERR != cyg_io_set_config(hDrvFlexCAN, CYG_IO_SET_CONFIG_CAN_INFO ,&can_cfg, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}*/
//
// create the two threads which access the CAN device driver
// a reader thread with a higher priority and a writer thread
// with a lower priority
//
cyg_thread_create(4, can0_thread,
(cyg_addrword_t) 0,
"can0_thread",
(void *) can0_thread_data.stack,
1024 * sizeof(long),
&can0_thread_data.hdl,
&can0_thread_data.obj);
cyg_thread_resume(can0_thread_data.hdl);
cyg_scheduler_start();
}示例15: sys_thread_new
/*
* Create new thread
*/
sys_thread_t sys_thread_new(void (*function) (void *arg), void *arg,int prio)
{
struct lwip_thread * nt;
void * stack;
static int thread_count = 0;
nt = (struct lwip_thread *)cyg_mempool_var_alloc(var_mempool_h, sizeof(struct lwip_thread));
nt->next = threads;
nt->to.next = NULL;
threads = nt;
stack = (void *)(memfix+CYGNUM_LWIP_THREAD_STACK_SIZE*thread_count++);
cyg_thread_create(prio, (cyg_thread_entry_t *)function, (cyg_addrword_t)arg,
(char *)arg , stack, CYGNUM_LWIP_THREAD_STACK_SIZE, &(nt->th), &(nt->t) );
cyg_thread_resume(nt->th);
return nt->th;
}