自学教程：C++ thread_create函数代码示例

uint8_t border_initialize(transceiver_type_t trans,ipv6_addr_t *border_router_addr) {    ipv6_addr_t addr;        serial_reader_pid = thread_create(            serial_reader_stack, READER_STACK_SIZE,            PRIORITY_MAIN-1, CREATE_STACKTEST,            serial_reader_f, "serial_reader");        if (border_router_addr == NULL) {        border_router_addr = &addr;                addr = flowcontrol_init();    }        /* only allow addresses generated accoding to      * RFC 4944 (Section 6) & RFC 2464 (Section 4) from short address      * -- for now     */    if (    border_router_addr->uint16[4] != HTONS(IEEE_802154_PAN_ID ^ 0x0200) ||            border_router_addr->uint16[5] != HTONS(0x00FF) ||            border_router_addr->uint16[6] != HTONS(0xFE00)        ) {        return SIXLOWERROR_ADDRESS;    }        // radio-address is 8-bit so this must be tested extra    if (border_router_addr->uint8[14] != 0) {        return SIXLOWERROR_ADDRESS;    }        memcpy(&(abr_addr.uint8[0]),&(border_router_addr->uint8[0]),16);        sixlowpan_init(trans,border_router_addr->uint8[15],1);        ipv6_init_iface_as_router();        return SUCCESS;}

int main(void){    puts("START");    kernel_pid_t pid = thread_create(stack,                  sizeof(stack),                  THREAD_PRIORITY_MAIN - 1,                  THREAD_CREATE_STACKTEST,                  _thread,                  NULL,                  "second_thread");    thread_t *thread = (thread_t*) thread_get(pid);    _set(thread, 0x1);    _set(thread, 0x64);    _set(thread, 0x1);    _set(thread, 0x8);    _set(thread, 0x2);    _set(thread, 0x4);    while(!done) {};    puts("main: setting 100ms timeout...");    xtimer_t t;    uint32_t before = xtimer_now_usec();    xtimer_set_timeout_flag(&t, TIMEOUT);    thread_flags_wait_any(THREAD_FLAG_TIMEOUT);    uint32_t diff = xtimer_now_usec() - before;    printf("main: timeout triggered. time passed: %uus/n", (unsigned)diff);    if (diff < (TIMEOUT + THRESHOLD)) {        puts("SUCCESS");        return 0;    }    puts("FAILURE");    return 1;}

void http_client_test2(void){	aio_worker_init();	pthread_t thread;	bool running = true;	thread_create(&thread, http_server_thread, &running);	struct http_header_t headers[3];	headers[0].name = "User-Agent";	headers[0].value = "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:34.0) Gecko/20100101 Firefox/34.0";	headers[1].name = "Accept-Language";	headers[1].value = "en-US,en;q=0.5";	headers[2].name = "Connection";	headers[2].value = "keep-alive";	// block IO	void *http = http_client_create("127.0.0.1", PORT, 1);	assert(0 == http_client_get(http, "/", headers, sizeof(headers)/sizeof(headers[0]), http_client_test_onreply, NULL));	assert(0 == http_client_get(http, "/img/bdlogo.png", headers, sizeof(headers)/sizeof(headers[0]), http_client_test_onreply, NULL));	assert(0 == http_client_get(http, "/", NULL, 0, http_client_test_onreply, NULL));	http_client_destroy(http);	// AIO	int32_t ref = 0;	http = http_client_create("127.0.0.1", PORT, 0);	assert(0 == http_client_get(http, "/", headers, sizeof(headers)/sizeof(headers[0]), http_client_test_onreply, &ref));	while(1 != ref) system_sleep(1000);	assert(0 == http_client_get(http, "/img/bdlogo.png", headers, sizeof(headers)/sizeof(headers[0]), http_client_test_onreply, &ref));	while(2 != ref) system_sleep(1000);	assert(0 == http_client_get(http, "/", NULL, 0, http_client_test_onreply, &ref));	while(3 != ref) system_sleep(1000);	http_client_destroy(http);	running = false;	thread_destroy(thread);	aio_worker_cleanup();}

void cc1100_phy_init(){    int i;    rx_buffer_head = 0;    rx_buffer_tail = 0;    rx_buffer_size = 0;    /* Initialize RX-Buffer (clear content) */    for (i = 0; i < RX_BUFF_SIZE; i++) {        rx_buffer->packet.length = 0;    }    /* Initialize handler table & packet monitor */    packet_monitor = NULL;    pm_init_table((pm_table_t *)&handler_table, MAX_PACKET_HANDLERS, handlers);    /* Clear sequence number buffer */    memset(seq_buffer, 0, sizeof(seq_buffer_entry_t) * MAX_SEQ_BUFFER_SIZE);    /* Initialize mutex */    cc1100_mutex_pid = -1;    mutex_init(&cc1100_mutex);    /* Allocate event numbers and start cc1100 event process */    cc1100_event_handler_pid = thread_create(event_handler_stack, sizeof(event_handler_stack), PRIORITY_CC1100, CREATE_STACKTEST,                               cc1100_event_handler_function, cc1100_event_handler_name);    /* Active watchdog for the first time */    if (radio_mode == CC1100_MODE_CONSTANT_RX) {        cc1100_watch_dog_period.microseconds = CC1100_WATCHDOG_PERIOD;        if (cc1100_watch_dog_period.microseconds != 0) {            timex_t temp = timex_set(0, 5000000L);            vtimer_set_msg(&cc1100_watch_dog, temp, cc1100_event_handler_pid, NULL);        }    }}

int main(void){	const char * ip_msg = "IPM message/n";	int64_t tick_orig;	printf("Application started (M:%u)!/n", mm_heap_available());	ipm_queue_init(&ipm_q, 2);	test_t = thread_create( "tst", &test_th_handle, NULL,			CONFIG_STACK_SIZE, test_thread_stack, 80);	tick_orig = sys_tick;		while(true) {		if(time_after(sys_tick, tick_orig + 3000))			printf("tm after: 3000/n");		ipm_post_msg(&ipm_q, ip_msg, strlen(ip_msg));		printf("maint mem: %u/n", mm_heap_available());		sleep(500);	}	return 0;}

/** * Example's executing routine * It has been declared by the macro EMBOX_EXAMPLE */static int run(int argc, char **argv) {	struct thread *thr[CONF_THREADS_QUANTITY];	int data[CONF_THREADS_QUANTITY];	void *ret;	int i;	/* starting all threads */	for(i = 0; i < ARRAY_SIZE(thr); i ++) {		data[i] = i;		//printf("starting thread %d with", i);		thr[i] = thread_create(0, thread_handler, &data[i]);		//printf(" id = %d/n", thr[i]->id);	}	/* waiting until all threads finish and print return value*/	for(i = 0; i < ARRAY_SIZE(thr); i ++) {		thread_join(thr[i], &ret);		//printf("finished thread id %d with result %d/n", i, *((int *)ret));	}	printf("/n");	return ENOERR;}

intmain(int argc, char *argv[]){  int a, b, c, d, f, g, h, i = 1;  int pid, pid2;  char *e;  g = (int)malloc(1);  a = (int)malloc(1);  b = (int)malloc(2);  c = (int)malloc(40);  f = (int)malloc(17);  h = (int)malloc(16);  e = (char *)c;  e+=20;  d = (int)e;  printf(1, "%s", "** Placeholder program for grading scripts **/n");  printf(1, "** g %d, a %d, b %d, c %d, d %d, f %d, h %d**/n", g, a, b, c, d, f, h);  pid = thread_create(worker,(void *)i);  pid2 = thread_join();  printf(1, "create pid = %d, join pid = %d/n", pid, pid2);  exit();}

int main(void){    puts("main starting");    kernel_pid_t pid = thread_create(stack,                  sizeof(stack),                  THREAD_PRIORITY_MAIN - 1,                  THREAD_CREATE_STACKTEST,                  _thread,                  NULL,                  "second_thread");    thread_t *thread = (thread_t*) thread_get(pid);    _set(thread, 0x1);    _set(thread, 0x64);    _set(thread, 0x1);    _set(thread, 0x8);    _set(thread, 0x2);    _set(thread, 0x4);    while(1) {};    return 0;}

kbrd_instance_t *kbrd_init(void){	kbrd_instance_t *instance	    = malloc(sizeof(kbrd_instance_t), FRAME_ATOMIC);	if (instance) {		instance->thread = thread_create(kkbrd, (void *) instance,		    TASK, THREAD_FLAG_NONE, "kkbrd");				if (!instance->thread) {			free(instance);			return NULL;		}				instance->sink = NULL;		indev_initialize("kbrd", &instance->raw, &kbrd_raw_ops);				spinlock_initialize(&instance->keylock, "kbrd.instance.keylock");		instance->keyflags = 0;		instance->lockflags = 0;	}		return instance;}

static thread_tthread_run(char *name, void (*start)(void),	   void *stack, size_t stack_size, int nice){	thread_t th = 0;	int rc;	if ((rc = thread_create(task_self(), &th)) != 0)		errx(1, "thread_create: %s", strerror(rc));	if ((rc = thread_load(th, start, (uint8_t*)stack + stack_size)) != 0)		errx(1, "thread_load: %s", strerror(rc));	thread_name(th, name);	if ((rc = thread_setprio(th, PRIO_DFLT + nice)) != 0)		errx(1, "thread_setprio: %s", strerror(rc));	if ((rc = thread_resume(th)) != 0)		errx(1, "thread_resume: %s", strerror(rc));	return th;}

// This is the main thread// In a real program, it should probably start all of the threads and then wait for them to finish// without doing any "real" workint main(void) {    printf("Main starting/n");        printf("Main calling thread_create/n");    // Start one other thread    thread_create(&test_thread);        printf("Main returned from thread_create/n");    // Loop, doing a little work then yielding to the other thread    while(1) {        printf("Main calling thread_yield/n");                thread_yield();                printf("Main returned from thread_yield/n");    }    // We should never get here    exit(0);    }

thread_port_t tgdb_thread_create(vm_offset_t entry){	kern_return_t	rc;	mach_thread_t th;	int i;	for (th = &threads[0], i=0; i<MAX_THREADS; i++, th++)		if (th->thread == MACH_PORT_NULL)			break;	if((rc = thread_create(mach_task_self(), &th->thread)) != KERN_SUCCESS) {		printf("tgdb: thread_create returned %d/n", rc);		return 0;	}	th->stack = stack_alloc(STACK_SIZE);	set_thread_self(th);	thread_set_regs(entry, th);	return th->thread;}

DECLARE_TEST( atomic, add ){    int num_threads = 32;    int ithread;    object_t threads[32];    for( ithread = 0; ithread < num_threads; ++ithread )        threads[ithread] = thread_create( add_thread, "add", THREAD_PRIORITY_NORMAL, 0 );    for( ithread = 0; ithread < num_threads; ++ithread )        thread_start( threads[ithread], 0 );    test_wait_for_threads_startup( threads, num_threads );    for( ithread = 0; ithread < num_threads; ++ithread )        thread_destroy( threads[ithread] );    test_wait_for_threads_exit( threads, num_threads );    EXPECT_EQ( val_32, 0 );    EXPECT_EQ( val_64, 0 );    return 0;}

int main(void) {		LED_RED_ON;#ifdef LED_GREEN_OFF    LED_GREEN_OFF;#endif	timer_over_pid = thread_create(timer_over_buf,	                               KERNEL_CONF_STACKSIZE_MAIN,	                               PRIORITY_MAIN-1,	                               CREATE_WOUT_YIELD | CREATE_STACKTEST,	                               blinker,	                               "blinker");	while(1) {#ifdef LED_GREEN_TOGGLE	  LED_GREEN_TOGGLE;#endif	  vtimer_usleep(SEC);	}	return 0;}

static void _handle_stats_request(connection_t *con,         http_parser_t *parser, char *uri){    stats_connection_t *stats;    stats_event_inc(NULL, "stats_connections");                    if (!connection_check_admin_pass(parser)) {        ERROR0("Bad password for stats connection");        connection_close(con);        httpp_destroy(parser);        return;    }                        stats_event_inc(NULL, "stats");                        /* create stats connection and create stats handler thread */    stats = (stats_connection_t *)malloc(sizeof(stats_connection_t));    stats->parser = parser;    stats->con = con;                        thread_create("Stats Connection", stats_connection, (void *)stats, THREAD_DETACHED);}

kernel_pid_t nhdp_start(void){    if (nhdp_pid == KERNEL_PID_UNDEF) {        /* Init destination address for NHDP's packets */        /* Start the NHDP thread */        nhdp_pid = thread_create(nhdp_stack, sizeof(nhdp_stack), THREAD_PRIORITY_MAIN - 1,                                 THREAD_CREATE_STACKTEST, _nhdp_runner, NULL, "NHDP");#if (NHDP_METRIC_NEEDS_TIMER)        /* Configure periodic timer message to refresh metric values */        if (nhdp_pid != KERNEL_PID_UNDEF) {            metric_interval = timex_from_uint64(DAT_REFRESH_INTERVAL * SEC_IN_USEC);            metric_msg.type = NHDP_METRIC_TIMER;            metric_msg.content.ptr = NULL;            xtimer_set_msg64(&metric_timer, timex_uint64(metric_interval),                             metric_msg, nhdp_pid);        }#endif    }    return nhdp_pid;}

int fibo(int argc, const cmd_args *argv){	if (argc < 2) {		printf("not enough args/n");		return -1;	}	lk_time_t tim = current_time();	thread_t *t = thread_create("fibo", &fibo_thread, (void *)(uintptr_t)argv[1].u, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE);	thread_resume(t);	int retcode;	thread_join(t, &retcode, INFINITE_TIME);	tim = current_time() - tim;	printf("fibo %d/n", retcode);	printf("took %u msecs to calculate/n", tim);	return NO_ERROR;}

int _stats_cmd(int argc, char **argv){    if (argc != 2) {        puts("Usage: stats [start|stop]");        return 1;    }    if (strcmp(argv[1], "start") == 0) {        if (_stats_pid == KERNEL_PID_UNDEF) {            _stats_pid = thread_create(stats_stack, sizeof(stats_stack), PRIO,                                       THREAD_CREATE_STACKTEST, _stats_print, NULL, "stats");        }        print_stats = true;    }    else if (strcmp(argv[1], "stop") == 0) {        print_stats = false;    }    else {        return 1;    }    return 0;}

intsmtsimu_init (void){    AGENT   *agent;                     /*  Handle for our agent             */    THREAD  *thread;                    /*  Handle to console thread         */#   include "smtsimu.i"                 /*  Include dialog interpreter       */    /*  Shutdown event comes from Kernel                                     */    declare_smtlib_shutdown   (shutdown_event, SMT_PRIORITY_MAX);    /*  Alarm event sent by kernel to this agent                             */    declare_smttime_reply     (alarm_event,    0);    declare_smttime_error     (error_event,    0);    /*  Ensure that operator console is running, else start it up            */    smtoper_init ();    if ((thread = thread_lookup (SMT_OPERATOR, "")) != NULL)        operq = thread-> queue-> qid;    else        return (-1);    /*  Ensure that timer agent is running, else start it up               */    if (smttime_init ())        return (-1);    /*  Create initial thread                                                */    if ((thread = thread_create (AGENT_NAME, "")) != NULL)        simuq = thread-> queue-> qid;    else        return (-1);    /*  Initialise static variables */    last_id = 0;    /*  Signal okay to caller that we initialised okay                       */    return (0);}

TID_t process_fork(void (*func)(int), int arg){    TID_t tid;    thread_table_t *thread = thread_get_current_thread_entry();    process_id_t pid = thread->process_id;    interrupt_status_t intr_status;    thread_params_t params;    params.done = 0;    params.func = func;    params.arg = arg;    params.pid = pid;    params.pagetable = thread->pagetable;    intr_status = _interrupt_disable();    spinlock_acquire(&process_table_slock);    tid = thread_create((void (*)(uint32_t))(setup_thread), (uint32_t)&params);    if (tid < 0) {        spinlock_release(&process_table_slock);        _interrupt_set_state(intr_status);        return -1;    }    process_table[pid].threads++;    spinlock_release(&process_table_slock);    _interrupt_set_state(intr_status);    thread_run(tid);    /* params will be dellocated when we return, so don't until the        new thread is ready. */    while (!params.done);    return tid;}

///-------------------------------------------------------------------------------------------------///  Begin a recursive scan of all paths previously provided to ms_add_path(). If async mode///   is enabled, this call will return immediately. You must obtain the file descriptor using///   ms_async_fd and this must be checked using an event loop or select(). When the fd becomes///   readable you must call ms_async_process to trigger any necessary callbacks.////// @author Andy Grundman/// @date 03/15/2011////// @param [in,out] s If non-null, the.////// ### remarks .///-------------------------------------------------------------------------------------------------void ms_scan(MediaScan *s) {  if (s->on_result == NULL) {    LOG_ERROR("Result callback not set, aborting scan/n");    goto out;  }  if (s->npaths == 0) {    LOG_ERROR("No paths set, aborting scan/n");    goto out;  }  if (s->async) {    thread_data_type *thread_data;    thread_data = (thread_data_type *)calloc(sizeof(thread_data_type), 1);    LOG_MEM("new thread_data @ %p/n", thread_data);    thread_data->lpDir = NULL;    thread_data->s = s;    s->thread = thread_create(do_scan, thread_data, s->async_fds);    if (!s->thread) {      LOG_ERROR("Unable to start async thread/n");      goto out;    }  }  else {    thread_data_type thread_data;    thread_data.s = s;    thread_data.lpDir = NULL;    do_scan(&thread_data);  }out:  return;}                               /* ms_scan() */

void MainDelayExit( void ){    int         i;    pthread_t   shutdownThreadId;    LogPrintNoArg( LOG_CRIT, "Shutting down" );    /* Signal to all that we are aborting */    BotDone = FALSE;    GlobalAbort = true;    /* Unload all plugins (which should kill all associated threads) */    pluginUnloadAll();    /* Send out signals from all queues waking up anything waiting on them so     * the listeners can unblock and die     */    QueueKillAll();    /* Shut down IRC connections */    thread_create( &shutdownThreadId, bot_shutdown, NULL, "thread_shutdown",                   NULL );    /* Delay to allow all the other tasks to finish (esp. logging!) */    for( i = 15; i && !BotDone; i-- ) {        sleep(1);    }    LogPrintNoArg(LOG_DEBUG, "Shutdown complete!" );    LogFlushOutput();    cursesAtExit();    /* And finally... die */    _exit( 0 );}

void init_transceiver(void){    kernel_pid_t radio_pid = thread_create(                        radio_stack_buffer,                        sizeof(radio_stack_buffer),                        PRIORITY_MAIN - 2,                        CREATE_STACKTEST,                        radio,                        NULL,                        "radio");    uint16_t transceivers = TRANSCEIVER_DEFAULT;    transceiver_init(transceivers);    transceiver_start();    transceiver_register(transceivers, radio_pid);    msg_t mesg;    mesg.type = SET_CHANNEL;    mesg.content.ptr = (char *) &tcmd;    uint16_t c = 10;    tcmd.transceivers = TRANSCEIVER_DEFAULT;    tcmd.data = &c;    printf("Set transceiver to channel %u/n", c);    msg_send(&mesg, transceiver_pid);    mesg.type = SET_MONITOR;    mesg.content.ptr = (char *) &tcmd;    uint16_t v = 1;    tcmd.data = &v;    printf("Set transceiver into monitor mode/n");    msg_send(&mesg, transceiver_pid);}

voidtest_preemptive(){	int ret;        long ii;	Tid potato_tids[NPOTATO];	unintr_printf("starting preemptive test/n");	unintr_printf("this test will take %d seconds/n", DURATION / 1000000);	gettimeofday(&pstart, NULL);	/* spin for sometime, so you see the interrupt handler output */	spin(SIG_INTERVAL * 5);	interrupts_quiet();	potato[0] = 1;	for (ii = 1; ii < NPOTATO; ii++) {		potato[ii] = 0;	}	for (ii = 0; ii < NPOTATO; ii++) {		potato_tids[ii] =			thread_create((void (*)(void *))do_potato, (void *)ii);		assert(thread_ret_ok(potato_tids[ii]));	}	spin(DURATION);	unintr_printf("cleaning hot potato/n");	for (ii = 0; ii < NPOTATO; ii++) {		ret = thread_exit(THREAD_ANY);		assert(thread_ret_ok(ret));	}	unintr_printf("preemptive test done/n");}

void shell(void* user){  char buffer[MAX_INPUT];  int i;  int command;  char* operand;  while(1){    print_str("/n Shell > ");    i=0;    buffer[i]='/0';           while(1){      if((*USART2_SR)&(USART_FLAG_RXNE)){          buffer[i]= (*USART2_DR) & 0xff;              }      if(buffer[i]==13 || buffer[i]=='/n'){         command = commandDetector(buffer);         switch (command){           case NUL:             break;           case FIBONACCI:                          operand = &buffer[10];             if (thread_create(fibonacci, (void*)operand ) == -1)	       print_str("fibonacci creation failed/r/n");                     break;           case HELP:             break;         }         break;      }else if(buffer[i]=='/0'){               }else{         print_str(&buffer[i++]);      }    }    bufferCleaner(buffer);  }}

int CMain::Run(){	if(m_Server.Init(this, m_Config.m_aBindAddr, m_Config.m_Port))		return 1;	if(ReadConfig())		return 1;	// Start JSON Update Thread	m_JSONUpdateThreadData.m_ReloadRequired = 2;	m_JSONUpdateThreadData.pClients = m_aClients;	m_JSONUpdateThreadData.pConfig = &m_Config;	void *LoadThread = thread_create(JSONUpdateThread, &m_JSONUpdateThreadData);	//thread_detach(LoadThread);	while(gs_Running)	{		if(gs_ReloadConfig)		{			if(ReadConfig())				return 1;			m_Server.NetBan()->UnbanAll();			gs_ReloadConfig = 0;		}		m_Server.Update();		// wait for incomming data		net_socket_read_wait(*m_Server.Network()->Socket(), 10);	}	dbg_msg("server", "Closing.");	m_Server.Network()->Close();	thread_wait(LoadThread);	return 0;}

/* start a new UDP server on given port */void udpif_start_server(uint16_t port, void(*ondata)(uint16_t src, char *data, int length)){    // allow only one server running at the same time - TODO this sucks, enable more then one!    if (server_socket > 0) {        printf("Error: UDP server already running/n");        return;    }    // open server socket    server_socket = tl_socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP);    if (server_socket < 0) {        printf("Error: Unable to open UDP server socket/n");    }    // set server address    memset(&server_addr, 0, sizeof(server_addr));    server_addr.sin6_family = AF_INET;    server_addr.sin6_port = HTONS(port);    // bind server socket    if (-1 == tl_socket_bind(server_socket, &server_addr, sizeof(server_addr))) {        printf("Error: Binding the server socket failed!/n");        tl_socket_close(server_socket);    }    // set on data callback    server_on_data = ondata;    // start server thread    int udpif_server_thread_pid = thread_create(server_stack,                                              KERNEL_CONF_STACKSIZE_MAIN,                                               PRIORITY_MAIN,                                               CREATE_STACKTEST,                                               server_loop,                                               "udp_server");    printf("UDP server started on port %d (Thread PID: %d)/n", port, udpif_server_thread_pid);}

void test2(void){    puts("first: sem_init");    if (sem_init(&s, 0, 0) != 0) {        puts("first: sem_init FAILED");    }    for (int i = 0; i < SEMAPHORE_TEST_THREADS; i++) {        int priority = THREAD_PRIORITY_MAIN - (i + 3) % 10 + 1;        snprintf(names[i], sizeof(names[i]), "priority %d", priority);        printf("first: thread create: %d/n", priority);        kernel_pid_t pid = thread_create(test2_thread_stack[i],                                         sizeof(test2_thread_stack[i]),                                         priority,                                         CREATE_STACKTEST,                                         priority_sema_thread,                                         names[i],                                         names[i]);        if (pid == KERNEL_PID_UNDEF) {            puts("first: thread create FAILED");        }        printf("first: thread created: %s (%d/%d)/n", names[i], i + 1, SEMAPHORE_TEST_THREADS);    }    puts("------------------------------------------");    for (int i = 0; i < SEMAPHORE_TEST_THREADS; i++) {        printf("post no. %d/n", i);        sem_post(&s);        puts("Back in main thread.");    }}

int main(void){    int tid;    if (ide_detect(&ide) < 0)    {        uprint("ATA: No IDE controller found. Bye!");        return 1;    }    if (!ide_initialize(&ide))    {        uprint("ATA: No disk have been detected. Bye!");        return 2;    }    uprint("ATA: configuration detected, creating devices ...");    for (int i = 0; i < 4; ++i)    {        if (ide.devices[i].exists)        {            tid = thread_create(driver_device_thread, 1, &ide.devices[i]);            if (tid < 0)                uprint("ATA: Fail to start thread");        }    }    while (1)        sleep(1);    return 0;}

int main(void){    memcpy(&sx127x.params, sx127x_params, sizeof(sx127x_params));    netdev = (netdev_t*) &sx127x;    netdev->driver = &sx127x_driver;    netdev->driver->init(netdev);    netdev->event_callback = _event_cb;    _recv_pid = thread_create(stack, sizeof(stack), THREAD_PRIORITY_MAIN - 1,                              THREAD_CREATE_STACKTEST, _recv_thread, NULL,                              "recv_thread");    if (_recv_pid <= KERNEL_PID_UNDEF) {        puts("Creation of receiver thread failed");        return 1;    }    /* start the shell */    puts("Initialization successful - starting the shell now");    char line_buf[SHELL_DEFAULT_BUFSIZE];    shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE);    return 0;}