//串口数据处理线程 void uart3_deal_entry(void* parameter) { rt_uint8_t buf[MAXLEN]; rt_uint8_t len_send; rt_sem_take(sem, RT_WAITING_FOREVER); while(1) { rt_sem_take(sem, RT_WAITING_FOREVER); rt_kprintf("received a packet\r\n"); if((recvcnt=dataunpack(uartbuff,uartrecvcnt,buf)) != 0)//对接收的数据进行解包放到buf中,解包后数据长度recvcnt { rt_uint8_t i; for(i=0;i<recvcnt;i++) { rt_kprintf("%02x ",buf[i]); } len_send = datapack(buf,2,uartbuff);//将要发送的buf中的2个数据进行打包后放到uartbuff中,打包后数据长度len_send rt_device_write(device,0,uartbuff,len_send); } uartrecvcnt = 0; uartbuff = uartcatch; curuartptr = uartcatch; uartstate = UART_IDLE; } }
/***************************************************************************//** * @brief * Draw a horizontal line with specified color * * @details * * @note * * @param[in] c * Pointer to color * * @param[in] x1 * Horizontal start position * * @param[in] x2 * Horizontal end position * * @param[in] y * Vertical position ******************************************************************************/ static void oled_drawHLine(rtgui_color_t *c, int x1, int x2, int y) { rt_err_t ret; rt_uint8_t color[MINISTM32_OLED_WIDTH], data[3]; rt_uint32_t i; if ((x1 >= MINISTM32_OLED_WIDTH) || (y >= MINISTM32_OLED_HEIGHT)) { return; } if (x2 >= MINISTM32_OLED_WIDTH) { x2 = MINISTM32_OLED_WIDTH - 1; } if (rt_hw_interrupt_check()) { ret = rt_sem_take(&oled_lock, RT_WAITING_NO); } else { ret = rt_sem_take(&oled_lock, RT_WAITING_FOREVER); } if (ret != RT_EOK) { return; } // Set column address data[0] = 0x21; data[1] = x1; data[2] = x2; oled_writeLongCmd(data, 3); // Set page address data[0] = 0x22; data[1] = y / 8; data[2] = y / 8; oled_writeLongCmd(data, 3); oled_readData(color, x2 - x1 + 1); for (i = 0; i < x2 - x1; i++) { color[i] &= ~(1 << (y % 8)); } if (*(rt_uint8_t *)c) { for (i = 0; i < x2 - x1; i++) { color[i] |= 1 << (y % 8); } } oled_writeData(color, x2 - x1 + 1); rt_sem_release(&oled_lock); }
void take_forks(int i) { /* 进入临界区*/ rt_sem_take(&sem_lock, RT_WAITING_FOREVER); phd_state[i] = HUNGRY; test(i); /* 退出临界区*/ rt_sem_release(&sem_lock); /* 如果不处于EATING状态则阻塞哲学家 */ rt_sem_take(&sem[i], RT_WAITING_FOREVER); }
/*********************************************************** * Function: * Description: * Input: * Input: * Output: * Return: * Others: ***********************************************************/ static void rt_thread_entry_sd_test( void* parameter ) { FRESULT res; char tempbuf[64]; rt_sem_take( &sem_dataflash, RT_TICK_PER_SECOND * FLASH_SEM_DELAY ); SPI_Configuration(); res = SD_Init(); if(0 == res) { rt_kprintf("\r\n SD CARD INIT OK!"); memset(tempbuf,0,sizeof(tempbuf)); SD_GetCID(tempbuf); rt_kprintf("\r\n CID="); printf_hex_data(tempbuf, 16); SD_GetCSD(tempbuf); rt_kprintf("\r\n SID="); printf_hex_data(tempbuf, 16); rt_kprintf("\r\n SD 容量=%d",SD_GetCapacity()); } else { rt_kprintf("\r\n SD CARD INIT ERR = %d",res); } if(0 == f_mount(MMC, &fs)) { rt_kprintf("\r\n f_mount SD OK!"); } rt_sem_release(&sem_dataflash); while( 1 ) { rt_thread_delay( RT_TICK_PER_SECOND / 20 ); } }
int si_get_item_in_wl_data(char *sn, union sinkinfo_ptc_ctc_st *item, rt_tick_t *time_stamp) { rt_err_t sem_ret; struct sinkinfo_wl_data_item_st *p; int ret = SUCC; if (NULL==sn || NULL==item || NULL==time_stamp) { printf_syn("func:%s(), param is NULL\n", __FUNCTION__); return FAIL; } sem_ret = rt_sem_take(&sink_wl_data_sem, RT_WAITING_FOREVER); if (RT_EOK != sem_ret) { printf_syn("take sink_wl_data_sem fail(%d)\n", ret); return FAIL; } p = si_lookup_item_in_wl_data(sn); if (NULL == p) { ret = FAIL; } else { rt_memcpy(item, &p->item, sizeof(*item)); *time_stamp = p->time_stamp; } rt_sem_release(&sink_wl_data_sem); return ret; }
void *rt_page_alloc(rt_size_t npages) { struct rt_page_head *b, *n; struct rt_page_head **prev; if(npages == 0) return RT_NULL; /* lock heap */ rt_sem_take(&heap_sem, RT_WAITING_FOREVER); for (prev = &rt_page_list; (b = *prev) != RT_NULL; prev = &(b->next)) { if (b->page > npages) { /* splite pages */ n = b + npages; n->next = b->next; n->page = b->page - npages; *prev = n; break; } if (b->page == npages) { /* this node fit, remove this node */ *prev = b->next; break; } } /* unlock heap */ rt_sem_release(&heap_sem); return b; }
int pthread_join (pthread_t thread, void **value_ptr) { _pthread_data_t* ptd; rt_err_t result; if (thread == rt_thread_self()) { /* join self */ return EDEADLK; } ptd = _pthread_get_data(thread); if (ptd->attr.detachstate == PTHREAD_CREATE_DETACHED) return EINVAL; /* join on a detached pthread */ result = rt_sem_take(ptd->joinable_sem, RT_WAITING_FOREVER); if (result == RT_EOK) { /* get return value */ if (value_ptr != RT_NULL) *value_ptr = ptd->return_value; /* release resource */ pthread_detach(thread); } else return ESRCH; return 0; }
/* * ind_m: master index * ind_s: slave index */ int write_syscfgdata_tbl(const unsigned int ind_m, const unsigned int ind_s, void *const data) { int ret = RT_EOK, i, cnt; struct syscfgdata_tbl *p; char *p1, *p2, *p3; rt_err_t ret_sem; if (ind_m >= SYSCFGDATA_TBL_BUTT || NULL == data) return RT_ERROR; ret_sem = rt_sem_take(&write_syscfgdata_sem, RT_WAITING_FOREVER); if (RT_EOK != ret_sem) { SYSCFG_DATA_LOG(("func:%s, line:%d, error(%d)", __FUNCTION__, __LINE__, ret_sem)); return RT_ERROR; } p = &syscfgdata_tbl_cache->syscfg_data; /* 作为保护性验证 */ if (SYSCFGDATA_TBL_MAGIC_NUM != p->systbl_head.magic_num) { rt_kprintf("the data of system config table cache is invalid!\n"); if (0 != read_whole_syscfgdata_tbl(p, SYSCFGDATA_TBL_SIZE_OF_FLASH)) { ret = RT_ERROR; goto out; } } SYSCFG_DATA_PRINT(("usr[0]:%#x, pw[0]:%#x \n", p->logindata[0].login.usr[0], p->logindata[0].login.pw[0])); SYSCFG_DATA_PRINT(("func:%s, line:%d, ind_m:%u, ind_s:%u \n", __FUNCTION__, __LINE__, ind_m, ind_s)); ret = get_member_start_and_size(ind_m, ind_s, p, &p2, &cnt); if(RT_EOK != ret) { SYSCFG_DATA_LOG(("func:%s, error(%d)", __FUNCTION__, ret)); goto out; } cnt *= 4; p1 = data; p3 = p2; /* 缓冲区中的位置 */ /* 检查所写数据与syscfgdata_tbl_cache->syscfg_data中的是否一致 */ for (i=0; i<cnt; ++i) if (*p1++ != *p2++) break; if (i < cnt) { /* 不一致, 写入syscfgdata_tbl_cache->syscfg_data中 */ p1 = data; p2 = p3; for (i=0; i<cnt; ++i) *p2++ = *p1++; //write_whole_syscfgdata_tbl(p); /* mark by David */ /* 设置数据已更新标志 */ set_syscfgdata_tbl_dirty(syscfgdata_tbl_cache->systbl_flag_set); } out: rt_sem_release(&write_syscfgdata_sem); return ret; }
rt_err_t rs485_recieve_check(u8 val) { if(rt_sem_take(uart1_sem, 30) == RT_EOK) { if (command_analysis()) { switch(command_byte) { case 0x11://call preset point if(Rocket_fir_data == val) return RT_EOK; break; default: break; } } } return RT_ERROR; }
void Sram_thread_entry(void* parameter) { rt_tick_t t1,t2; SRAM_Init(); Fill_Buffer(aTxBuffer, BUFFER_SIZE, 0xA244250F); //DMA_Config(); // while(flag) // { // rt_thread_delay(1); // } rt_sem_take(&rt_sram_sem, RT_WAITING_FOREVER); while(flag1) { int fd; //int i=1024; fd = open("/ud/text.txt", O_WRONLY | O_CREAT,0); if (fd >= 0) { t1 = rt_tick_get(); // while(i>0) // { write(fd, RAM_Buffer, sizeof(RAM_Buffer)); // i--; // } t2 = rt_tick_get(); rt_kprintf("%d\n\r",t2-t1); close(fd); } rt_thread_delay(100); //SRAM_ReadBuffer(aTxBuffer,0,BUFFER_SIZE); } while(1); //Fill_Buffer(aTxBuffer, BUFFER_SIZE, 0xA244250F); }
rt_err_t gsm_send_wait_func( char *AT_cmd_string, uint32_t timeout, RESP_FUNC respfunc, uint8_t no_of_attempts ) { rt_err_t err; uint8_t i; char *pmsg; uint32_t tick_start, tick_end; uint32_t tm; __IO uint8_t flag_wait; char * pinfo; uint16_t len; err = rt_sem_take( &sem_at, timeout ); if( err != RT_EOK ) { return err; } for( i = 0; i < no_of_attempts; i++ ) { tick_start = rt_tick_get( ); tick_end = tick_start + timeout; tm = timeout; flag_wait = 1; rt_kprintf( "%08d gsm>%s\r\n", tick_start, AT_cmd_string ); m66_write( &dev_gsm, 0, AT_cmd_string, strlen( AT_cmd_string ) ); while( flag_wait ) { err = rt_mb_recv( &mb_gsmrx, (rt_uint32_t*)&pmsg, tm ); if( err == RT_EOK ) /*没有超时,判断信息是否正确*/ { len = ( *pmsg << 8 ) | ( *( pmsg + 1 ) ); pinfo = pmsg + 2; if( respfunc( pinfo, len ) == RT_EOK ) /*找到了*/ { rt_free( pmsg ); /*释放*/ rt_sem_release( &sem_at ); return RT_EOK; } rt_free( pmsg ); /*释放*/ /*计算剩下的超时时间,由于其他任务执行的延时,会溢出,要判断*/ if( rt_tick_get( ) < tick_end ) /*还没有超时*/ { tm = tick_end - rt_tick_get( ); }else { flag_wait = 0; } }else /*已经超时*/ { flag_wait = 0; } } } rt_sem_release( &sem_at ); return ( -RT_ETIMEOUT ); }
/* * 获取电压、电流波形采样数据, 每个点是4字节的有符号数据, 以网络序存储 * * 当返回值为SIE_OK时,非空指针指向的内存区域存储了返回值 */ enum sinkinfo_error_e get_sinkinfo_sample_data(int em_no, enum sinkinfo_cmd_e cmd, void *data_buf, int len) { enum sinkinfo_error_e ret = SIE_OK; if (len < SINK_INFO_PX_SAMPLE_BUF_SIZE) { printf_syn("func:%s, buf too small(%d)\n", __FUNCTION__, len); return SIE_BUF2SMALL; } // ret = rt_sem_take(&px_sample_data_sem, RT_WAITING_FOREVER); ret = rt_sem_take(&sinkinfo_sem, RT_WAITING_FOREVER); if (RT_EOK != ret) { printf_syn("take px_sample_data_sem fail(%d)\n", ret); return SIE_FAIL; } switch (cmd) { /* 以下命令返回数据量较大,大约(40*3+4)字节 */ case SIC_GET_PAV_SAMPLE_DATA: /* a相电压波形采样值 */ // conv_3bsinged_to_4bsinged(data_buf, len, sinkinfo_all_em[0].px_vi_sample.pa_vi_sample[0], SINK_INFO_PX_SAMPLE_BUF_SIZE); rt_memcpy(data_buf, sinkinfo_all_em[em_no].px_vi_sample.pa_vi_sample[0], len); break; case SIC_GET_PBV_SAMPLE_DATA: // conv_3bsinged_to_4bsinged(data_buf, len, sinkinfo_all_em[0].px_vi_sample.pb_vi_sample[0], SINK_INFO_PX_SAMPLE_BUF_SIZE); rt_memcpy(data_buf, sinkinfo_all_em[em_no].px_vi_sample.pb_vi_sample[0], len); break; case SIC_GET_PCV_SAMPLE_DATA: // conv_3bsinged_to_4bsinged(data_buf, len, sinkinfo_all_em[0].px_vi_sample.pc_vi_sample[0], SINK_INFO_PX_SAMPLE_BUF_SIZE); rt_memcpy(data_buf, sinkinfo_all_em[em_no].px_vi_sample.pc_vi_sample[0], len); break; case SIC_GET_PAI_SAMPLE_DATA: /* a相电流波形采样值 */ // conv_3bsinged_to_4bsinged(data_buf, len, sinkinfo_all_em[0].px_vi_sample.pa_vi_sample[1], SINK_INFO_PX_SAMPLE_BUF_SIZE); rt_memcpy(data_buf, sinkinfo_all_em[em_no].px_vi_sample.pa_vi_sample[1], len); break; case SIC_GET_PBI_SAMPLE_DATA: // conv_3bsinged_to_4bsinged(data_buf, len, sinkinfo_all_em[0].px_vi_sample.pb_vi_sample[1], SINK_INFO_PX_SAMPLE_BUF_SIZE); rt_memcpy(data_buf, sinkinfo_all_em[em_no].px_vi_sample.pb_vi_sample[1], len); break; case SIC_GET_PCI_SAMPLE_DATA: // conv_3bsinged_to_4bsinged(data_buf, len, sinkinfo_all_em[0].px_vi_sample.pc_vi_sample[1], SINK_INFO_PX_SAMPLE_BUF_SIZE); rt_memcpy(data_buf, sinkinfo_all_em[em_no].px_vi_sample.pc_vi_sample[1], len); break; default: ret = SIE_INVALID_CMD; printf_syn("func:%s, invalid cmd\n", __FUNCTION__); break; } // rt_sem_release(&px_sample_data_sem); rt_sem_release(&sinkinfo_sem); return ret; }
void mmcsd_send_request(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req) { do { req->cmd->retries--; req->cmd->err = 0; req->cmd->mrq = req; if (req->data) { req->cmd->data = req->data; req->data->err = 0; req->data->mrq = req; if (req->stop) { req->data->stop = req->stop; req->stop->err = 0; req->stop->mrq = req; } } host->ops->request(host, req); rt_sem_take(&host->sem_ack, RT_WAITING_FOREVER); } while(req->cmd->err && (req->cmd->retries > 0)); }
void rt_rs485_thread_entry(void* parameter) { char ch; while (1) { /* wait receive */ if (rt_sem_take(&uart1_dev_my->rx_sem, RT_WAITING_FOREVER) != RT_EOK) continue; /* read one character from device */ while (rt_device_read(uart1_dev_my->device, 0, &ch, 1) == 1) { #if 0 u8 datatmp; datatmp = ch; rs485_send_data(&datatmp, 1); #endif pelco_rx_isr(ch); } /* end of device read */ } }
/* worker线程入口 */ static void worker_entry(void* parameter) { rt_bool_t result; rt_uint32_t index, setchar; rt_uint8_t data_buffer[BUFFER_ITEM]; setchar = 0x21; while (1) { /* 构造数据 */ for(index = 0; index < BUFFER_ITEM; index++) { data_buffer[index] = setchar; if (++setchar == 0x7f) setchar = 0x21; } /* 持有信号量 */ rt_sem_take(sem, RT_WAITING_FOREVER); /* 把数据放到环形buffer中 */ result = rb_put(&working_rb, &data_buffer[0], BUFFER_ITEM); /* 释放信号量 */ rt_sem_release(sem); /* 放入成功,做一个10 OS Tick的休眠 */ rt_thread_delay(10); } }
static err_t ethernetif_linkoutput(struct netif *netif, struct pbuf *p) { #ifndef LWIP_NO_TX_THREAD struct eth_tx_msg msg; struct eth_device* enetif; RT_ASSERT(netif != RT_NULL); enetif = (struct eth_device*)netif->state; /* send a message to eth tx thread */ msg.netif = netif; msg.buf = p; if (rt_mb_send(ð_tx_thread_mb, (rt_uint32_t) &msg) == RT_EOK) { /* waiting for ack */ rt_sem_take(&(enetif->tx_ack), RT_WAITING_FOREVER); } #else struct eth_device* enetif; RT_ASSERT(netif != RT_NULL); enetif = (struct eth_device*)netif->state; if (enetif->eth_tx(&(enetif->parent), p) != RT_EOK) { return ERR_IF; } #endif return ERR_OK; }
rt_err_t _pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, rt_int32_t timeout) { rt_err_t result; if (!cond || !mutex) return -RT_ERROR; /* check whether initialized */ if (cond->attr == -1) pthread_cond_init(cond, RT_NULL); /* The mutex was not owned by the current thread at the time of the call. */ if (mutex->lock.owner != pthread_self()) return -RT_ERROR; /* unlock a mutex failed */ if (pthread_mutex_unlock(mutex) != 0) return -RT_ERROR; result = rt_sem_take(&(cond->sem), timeout); /* lock mutex again */ pthread_mutex_lock(mutex); return result; }
/* transmit packet. */ rt_err_t rt_stm32_eth_tx( rt_device_t dev, struct pbuf* p) { rt_err_t ret; struct pbuf *q; uint32_t l = 0; u8 *buffer ; if (( ret = rt_sem_take(&tx_wait, netifGUARD_BLOCK_TIME) ) == RT_EOK) { buffer = (u8 *)(DMATxDescToSet->Buffer1Addr); for(q = p; q != NULL; q = q->next) { //show_frame(q); rt_memcpy((u8_t*)&buffer[l], q->payload, q->len); l = l + q->len; } if( ETH_Prepare_Transmit_Descriptors(l) == ETH_ERROR ) rt_kprintf("Tx Error\n"); //rt_sem_release(xTxSemaphore); rt_sem_release(&tx_wait); //rt_kprintf("Tx packet, len = %d\n", l); } else { rt_kprintf("Tx Timeout\n"); return ret; } /* Return SUCCESS */ return RT_EOK; }
int read_syscfgdata_tbl(unsigned int ind_m, unsigned int ind_s, void *data) { char *p1; char *p2; int i, cnt, ret = RT_EOK; rt_err_t ret_sem; if (ind_m >= SYSCFGDATA_TBL_BUTT || NULL == data || !IS_SYSCFG_TBL_OF_FLASH_VALID) return RT_ERROR; ret_sem = rt_sem_take(&write_syscfgdata_sem, RT_WAITING_FOREVER); if (RT_EOK != ret_sem) { SYSCFG_DATA_LOG(("func:%s, line:%d, error(%d)", __FUNCTION__, __LINE__, ret_sem)); return RT_ERROR; } p1 = data; if(RT_EOK != get_member_start_and_size(ind_m, ind_s, SYSCFGDATA_TBL_BASE_ADDR_OF_FLASH, &p2, &cnt)) { SYSCFG_DATA_LOG(("func:%s, error", __FUNCTION__)); ret = RT_ERROR; goto ret_entry; } cnt *= 4; for (i=0; i<cnt; ++i) *p1++ = *p2++; ret_entry: rt_sem_release(&write_syscfgdata_sem); return ret; }
void rs485_recieve_test(void) { while(1) { if(RT_EOK == rs485_recieve_check(0x99)) { cam_filter_mode = Rocket_sec_data-1; if(cam_filter_mode>3) cam_filter_mode = 0; iris_mode = Rocket_thr_data&0x0f; //iris_motor_mode = (Rocket_thr_data>>4)&0x0f; osd_line3_disp(0); } } while(1) { if(rt_sem_take(uart1_sem, 200) == RT_EOK) { rs485_send_data(keyboard_data_buffer, 7); } } }
void tf_open(char *name) { FRESULT res; int len; char buffer[512]; rt_kprintf("\r\ntf_open enter;"); rt_sem_take( &sem_dataflash, RT_TICK_PER_SECOND * FLASH_SEM_DELAY ); sprintf(buffer,"%s",name); res = f_open(&file, buffer, FA_READ | FA_WRITE); rt_kprintf("\r\n f_open = %d",res); if(res == 0) { rt_kprintf("\r\n %s=",buffer); while(1) { memset(buffer,0,sizeof(buffer)); res = f_read(&file,buffer,sizeof(buffer),&len); if(res || len == 0) { break; } rt_kprintf("%s",buffer); } rt_kprintf("\r\n"); f_close(&file); } rt_sem_release(&sem_dataflash); }
//串口接收数据线程 void uart_thread_entry(void* parameter) { char ch; device = rt_device_find("uart3"); if(device != RT_NULL) { rt_device_open(device, RT_DEVICE_OFLAG_RDWR); rt_kprintf("open device uart3 succeed!\r\n"); rt_sem_init(&rx_sem, "uartrx", 0, 0); rt_device_set_rx_indicate(device, uart_rx_ind); while(1) { if (rt_sem_take(&rx_sem, RT_WAITING_FOREVER) != RT_EOK) //默认情况线程挂起,有数据时,系统会调用uart_rx_ind函数,释放信号量,线程得以执行 continue; while(rt_device_read(device, 0, &ch, 1) == 1) { uartRecvProc(ch); } } } }
/***************************************************************************//** * @brief * Get the color of a pixel * * @details * * @note * * @param[out] c * Pointer to color * * @param[in] x * Horizontal position * * @param[in] y * Vertical position ******************************************************************************/ static void oled_getPixel(rtgui_color_t *c, int x, int y) { rt_err_t ret; rt_uint8_t color, data[3]; if ((x >= MINISTM32_OLED_WIDTH) || (y >= MINISTM32_OLED_HEIGHT)) { return; } if (rt_hw_interrupt_check()) { ret = rt_sem_take(&oled_lock, RT_WAITING_NO); } else { ret = rt_sem_take(&oled_lock, RT_WAITING_FOREVER); } if (ret != RT_EOK) { return; } // Set column address data[0] = 0x21; data[1] = x; data[2] = x; oled_writeLongCmd(data, 3); // Set page address data[0] = 0x22; data[1] = y / 8; data[2] = y / 8; oled_writeLongCmd(data, 3); oled_readData(&color, 1); if (color & (1 << (y % 8))) { *(rt_uint8_t *)c = 0x01; } else { *(rt_uint8_t *)c = 0x00; } rt_sem_release(&oled_lock); }
/* 线程入口 */ static void thread_entry(void* parameter) { rt_err_t result; rt_tick_t tick; /* 获得当前的OS Tick */ tick = rt_tick_get(); /* 试图持有信号量,最大等待10个OS Tick后返回 */ result = rt_sem_take(&sem, 10); if (result == -RT_ETIMEOUT) { /* 超时后判断是否刚好是10个OS Tick */ if (rt_tick_get() - tick != 10) { tc_done(TC_STAT_FAILED); rt_sem_detach(&sem); return; } rt_kprintf("take semaphore timeout\n"); } else { /* 因为没有其他地方是否信号量,所以不应该成功持有信号量,否则测试失败 */ tc_done(TC_STAT_FAILED); rt_sem_detach(&sem); return; } /* 释放一次信号量 */ rt_sem_release(&sem); /* 永久等待方式持有信号量 */ result = rt_sem_take(&sem, RT_WAITING_FOREVER); if (result != RT_EOK) { /* 不成功则测试失败 */ tc_done(TC_STAT_FAILED); rt_sem_detach(&sem); return; } /* 测试通过 */ tc_done(TC_STAT_PASSED); /* 脱离信号量对象 */ rt_sem_detach(&sem); }
int rcu_uart_read(char* buf, int bufLen) { int ret = 0,rlen=0; int flag=0; char ch=0; char* p = buf; if(p == NULL) { return -1; } while(1) { if (rt_sem_take(&rcuReadSem, RT_WAITING_FOREVER) != RT_EOK) return ret; while(rt_device_read(rcuDevice, 0, &ch, 1)==1) { hclog("rcu_uart_read()--ch:0x%02x \n",ch); if(ch == '\r') { flag = 1; //break; } else if(flag==1) { if(ch=='\n') { rlen--; flag=2; break; } else { flag=0; } } if(rlen<bufLen-1) { *p = ch; p++; } rlen++; //if(ch == 0XCE) //{ // flag = 2; // break; //} } if(flag==2) break; } ret = rlen; if(rlen<bufLen) buf[rlen]=0; return ret; }
void benchmark() { rt_err_t result; rt_thread_t tid; rt_uint8_t* ptr; result = rt_sem_init(&ack, "ack", 0, RT_IPC_FLAG_FIFO); if (result != RT_EOK) { rt_kprintf("init ack semaphore failed\n"); return; } rt_kprintf("internal SRAM benchmark\n"); result = rt_thread_init(&benchmark_thread, "t1", benchmark_thread_entry, benchmark_buffer, &benchmark_thread_stack[0], sizeof(benchmark_thread_stack), 20, 10); if (result == RT_EOK) rt_thread_startup(&benchmark_thread); /* wait thread complete */ rt_sem_take(&ack, RT_WAITING_FOREVER); rt_thread_detach(&benchmark_thread); rt_kprintf("external SRAM benchmark\n"); ptr = rt_malloc(BENCHMARK_SIZE); /* create benchmark thread */ tid = rt_thread_create("t2", benchmark_thread_entry, ptr, 512, 20, 10); if (tid != RT_NULL) rt_thread_startup(tid); /* wait thread complete */ rt_sem_take(&ack, RT_WAITING_FOREVER); /* release memory */ rt_free(ptr); /* detach semaphore */ rt_sem_detach(&ack); }
/*********************************************************** * Function: * Description: * Input: * Input: * Output: * Return: * Others: ***********************************************************/ rt_err_t gsm_send_wait_str_ok( char *AT_cmd_string, uint32_t timeout, char * respstr, uint8_t no_of_attempts ) { rt_err_t err; uint8_t i = 0; char *pmsg; uint32_t tick_start, tick_end; uint32_t tm; __IO uint8_t flag_wait = 1; err = rt_sem_take( &sem_at, timeout ); if( err != RT_EOK ) { return err; } for( i = 0; i < no_of_attempts; i++ ) { tick_start = rt_tick_get( ); tick_end = tick_start + timeout; tm = timeout; flag_wait = 1; rt_kprintf( "%08d gsm>%s\r\n", tick_start, AT_cmd_string ); m66_write( &dev_gsm, 0, AT_cmd_string, strlen( AT_cmd_string ) ); while( flag_wait ) { err = rt_mb_recv( &mb_gsmrx, (rt_uint32_t*)&pmsg, tm ); if( err == RT_EOK ) /*没有超时,判断信息是否正确*/ { if( strstr( pmsg + 2, respstr ) != RT_NULL ) /*找到了*/ { rt_free( pmsg ); /*释放*/ goto lbl_send_wait_ok; } rt_free( pmsg ); /*释放*/ /*计算剩下的超时时间,由于其他任务执行的延时,会溢出,要判断*/ if( rt_tick_get( ) < tick_end ) /*还没有超时*/ { tm = tick_end - rt_tick_get( ); }else { flag_wait = 0; } }else /*已经超时*/ { flag_wait = 0; } } } rt_sem_release( &sem_at ); return -RT_ETIMEOUT; lbl_send_wait_ok: err = gsm_wait_str( "OK", RT_TICK_PER_SECOND * 2 ); rt_sem_release( &sem_at ); return err; }
void print_sink_data(void) { int i, j, k; struct sinkinfo_wl_data_item_st *p; rt_err_t ret; char title[DEV_SN_BUF_STRING_WITH_NUL_LEN_MAX+4]; if (NULL == sink_wl_collect_data) { printf_syn("func:%s(), sink_wl_collect_data is NULL\n", __FUNCTION__); return; } ret = rt_sem_take(&sink_wl_data_sem, RT_WAITING_FOREVER); if (RT_EOK != ret) { printf_syn("take sink_wl_data_sem fail(%d)\n", ret); return; } p = sink_wl_collect_data; #if 0 rt_strncpy(title, p->pt_ct_sn, sizeof(title)); i = rt_strlen(p->pt_ct_sn); title[i++] = ' '; title[i++] = 'p'; title[i++] = 'a'; j = i - 1; title[i++] = '-'; title[i++] = '\0'; #endif for (k=0; k<SINKINFO_WL_DATA_ITEM_MAX_NO; ++k) { if ('\0' != p->pt_ct_sn[0]) { rt_strncpy(title, p->pt_ct_sn, sizeof(title)); i = rt_strlen(p->pt_ct_sn); title[i++] = ' '; title[i++] = 'p'; title[i++] = 'a'; j = i - 1; title[i++] = '-'; title[i++] = '\0'; printf_syn("index %4d:\n", k); print_pt_ct_st_info(title, &p->item.ptc_data.pt_pa); title[j] = 'b'; print_pt_ct_st_info(title, &p->item.ptc_data.pt_pb); title[j] = 'c'; print_pt_ct_st_info(title, &p->item.ptc_data.pt_pc); } ++p; } rt_sem_release(&sink_wl_data_sem); return; }
static rt_bool_t getc(char * ch) { if((rt_sem_take(&remote_sem,RT_TICK_PER_SECOND/2))==RT_EOK) { rt_device_read(uart,0,ch,1); debug("%02X ",*ch); return RT_TRUE; } return RT_FALSE; }
/* transmit packet. */ rt_err_t lpc17xx_emac_tx( rt_device_t dev, struct pbuf* p) { rt_uint32_t Index, IndexNext; struct pbuf *q; rt_uint8_t *ptr; /* calculate next index */ IndexNext = LPC_EMAC->TxProduceIndex + 1; if(IndexNext > LPC_EMAC->TxDescriptorNumber) IndexNext = 0; /* check whether block is full */ while (IndexNext == LPC_EMAC->TxConsumeIndex) { rt_err_t result; rt_uint32_t recved; /* there is no block yet, wait a flag */ result = rt_event_recv(&tx_event, 0x01, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved); RT_ASSERT(result == RT_EOK); } /* lock EMAC device */ rt_sem_take(&sem_lock, RT_WAITING_FOREVER); /* get produce index */ Index = LPC_EMAC->TxProduceIndex; /* calculate next index */ IndexNext = LPC_EMAC->TxProduceIndex + 1; if(IndexNext > LPC_EMAC->TxDescriptorNumber) IndexNext = 0; /* copy data to tx buffer */ q = p; ptr = (rt_uint8_t*)TX_BUF(Index); while (q) { memcpy(ptr, q->payload, q->len); ptr += q->len; q = q->next; } TX_DESC_CTRL(Index) &= ~0x7ff; TX_DESC_CTRL(Index) |= (p->tot_len - 1) & 0x7ff; /* change index to the next */ LPC_EMAC->TxProduceIndex = IndexNext; /* unlock EMAC device */ rt_sem_release(&sem_lock); return RT_EOK; }