//串口数据处理线程
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;
}
