/* 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);
}
}
/* ethernet buffer */
void eth_tx_thread_entry(void* parameter)
{
struct eth_tx_msg* msg;
while (1)
{
if (rt_mb_recv(ð_tx_thread_mb, (rt_uint32_t*)&msg, RT_WAITING_FOREVER) == RT_EOK)
{
struct eth_device* enetif;
RT_ASSERT(msg->netif != RT_NULL);
RT_ASSERT(msg->buf != RT_NULL);
enetif = (struct eth_device*)msg->netif->state;
if (enetif != RT_NULL)
{
/* call driver's interface */
if (enetif->eth_tx(&(enetif->parent), msg->buf) != RT_EOK)
{
rt_kprintf("transmit eth packet failed\n");
}
}
/* send ack */
rt_sem_release(&(enetif->tx_ack));
}
}
}
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 *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;
}
/***********************************************************
* 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 );
}
}
/* 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;
}
void DMA1_Channel7_IRQHandler(void)
{
if (DMA_GetITStatus(DMAx_RX_FLAG_TCIF) != RESET) {
rt_interrupt_enter();
DMA_Cmd(DMAx_RX_CHANNEL, DISABLE);
DMA_ClearITPendingBit(DMAx_RX_FLAG_TCIF);
I2C_GenerateSTOP(I2Cx, ENABLE);
rt_sem_release(&DMA_RX_Sem);
rt_interrupt_leave();
}
else
{
DMA_ClearITPendingBit(DMAx_RX_FLAG_TEIF);
rt_kprintf("DMA RX ERROR!\nSR1=0x%04x\nSR1=0x%04x\nDR=0x%04x\nCCR=0x%04x\nCR1=0x%04x\nCR2=0x%04x\n",
I2Cx->SR1,
I2Cx->SR2,
I2Cx->DR,
I2Cx->CCR,
I2Cx->CR1,
I2Cx->CR2);
}
}
static rt_err_t uart485_3_rx_ind(rt_device_t dev, rt_size_t size)
{
rt_sem_release(&uart485_3_rx_msg_sem);
// rt_kprintf("**%s(), len:%u\n", __FUNCTION__, size);
return RT_EOK;
}
/*
* 获取电压、电流波形采样数据, 每个点是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;
}
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;
}
static void tcpip_init_done_callback(void *arg)
{
rt_device_t device;
struct eth_device *ethif;
struct ip_addr ipaddr, netmask, gw;
struct rt_list_node* node;
struct rt_object* object;
struct rt_object_information *information;
extern struct rt_object_information rt_object_container[];
LWIP_ASSERT("invalid arg.\n",arg);
IP4_ADDR(&gw, 0,0,0,0);
IP4_ADDR(&ipaddr, 0,0,0,0);
IP4_ADDR(&netmask, 0,0,0,0);
/* enter critical */
rt_enter_critical();
/* for each network interfaces */
information = &rt_object_container[RT_Object_Class_Device];
for (node = information->object_list.next; node != &(information->object_list); node = node->next)
{
object = rt_list_entry(node, struct rt_object, list);
device = (rt_device_t) object;
if (device->type == RT_Device_Class_NetIf)
{
ethif = (struct eth_device*)device;
/* leave critical */
rt_exit_critical();
netif_add(ethif->netif, &ipaddr, &netmask, &gw,
ethif, netif_device_init, tcpip_input);
if (netif_default == NULL)
netif_set_default(ethif->netif);
#if LWIP_DHCP
dhcp_start(ethif->netif);
#else
netif_set_up(ethif->netif);
#endif
#ifdef LWIP_NETIF_LINK_CALLBACK
netif_set_link_up(ethif->netif);
#endif
/* enter critical */
rt_enter_critical();
}
}
/* leave critical */
rt_exit_critical();
rt_sem_release((rt_sem_t)arg);
}
rt_err_t usart_rx_indicate(rt_device_t dev, rt_size_t size)
{
while(size--)
{
rt_sem_release(&rx_sem);
}
return RT_EOK;
}
void tc_done(rt_uint8_t stat)
{
_tc_stat |= stat;
_tc_stat &= ~TC_STAT_RUNNING;
/* release semaphore */
rt_sem_release(&_tc_sem);
}
void pthread_exit (void* value)
{
_pthread_data_t* ptd;
_pthread_cleanup_t* cleanup;
extern _pthread_key_data_t _thread_keys[PTHREAD_KEY_MAX];
ptd = _pthread_get_data(rt_thread_self());
rt_enter_critical();
/* disable cancel */
ptd->cancelstate = PTHREAD_CANCEL_DISABLE;
/* set return value */
ptd->return_value = value;
rt_exit_critical();
/* invoke pushed cleanup */
while (ptd->cleanup != RT_NULL)
{
cleanup = ptd->cleanup;
ptd->cleanup = cleanup->next;
cleanup->cleanup_func(cleanup->parameter);
/* release this cleanup function */
rt_free(cleanup);
}
/* destruct thread local key */
if (ptd->tls != RT_NULL)
{
void* data;
rt_uint32_t index;
for (index = 0; index < PTHREAD_KEY_MAX; index ++)
{
if (_thread_keys[index].is_used)
{
data = ptd->tls[index];
if (data)
_thread_keys[index].destructor(data);
}
}
/* release tls area */
rt_free(ptd->tls);
ptd->tls = RT_NULL;
}
if (ptd->attr.detachstate == PTHREAD_CREATE_JOINABLE)
{
/* release the joinable pthread */
rt_sem_release(ptd->joinable_sem);
}
/* detach thread */
rt_thread_detach(ptd->tid);
/* reschedule thread */
rt_schedule();
}
int pthread_rwlock_destroy (pthread_rwlock_t *rwlock)
{
int result;
if (!rwlock) return EINVAL;
if (rwlock->attr == -1) return 0; /* rwlock is not initialized */
if ( (result = pthread_mutex_lock(&rwlock->rw_mutex)) != 0)
return(result);
if (rwlock->rw_refcount != 0 ||
rwlock->rw_nwaitreaders != 0 || rwlock->rw_nwaitwriters != 0)
{
result = EBUSY;
return(EBUSY);
}
else
{
/* check whether busy */
result = rt_sem_trytake(&(rwlock->rw_condreaders.sem));
if (result == RT_EOK)
{
result = rt_sem_trytake(&(rwlock->rw_condwriters.sem));
if (result == RT_EOK)
{
rt_sem_release(&(rwlock->rw_condreaders.sem));
rt_sem_release(&(rwlock->rw_condwriters.sem));
pthread_cond_destroy(&rwlock->rw_condreaders);
pthread_cond_destroy(&rwlock->rw_condwriters);
}
else
{
rt_sem_release(&(rwlock->rw_condreaders.sem));
result = EBUSY;
}
}
else result = EBUSY;
}
pthread_mutex_unlock(&rwlock->rw_mutex);
if (result == 0) pthread_mutex_destroy(&rwlock->rw_mutex);
return result;
}
void rt_soft_timer_tick_increase(void)
{
timer_ex_cnt ++;
if (timer_ex_cnt >= (RT_TICK_PER_SECOND / RT_TIMER_TICK_PER_SECOND))
{
timer_ex_cnt = 0;
rt_sem_release(&timer_sem);
}
}
static rt_err_t rs485_rx_ind(rt_device_t dev, rt_size_t size)
{
RT_ASSERT(uart1_dev_my != RT_NULL);
/* release semaphore to let thread rx data */
rt_sem_release(&uart1_dev_my->rx_sem);
return RT_EOK;
}
static rt_err_t finsh_rx_ind(rt_device_t dev, rt_size_t size)
{
RT_ASSERT(shell != RT_NULL);
/* release semaphore to let finsh thread rx data */
rt_sem_release(&shell->rx_sem);
return RT_EOK;
}
static void worker_thread_entry(void* parameter)
{
rt_thread_delay(10);
while (1) {
rt_sem_release(sem);
rt_thread_delay(5);
}
}
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;
}
/***************************************************************************//**
* @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);
}
/**
* This function will release the previously allocated memory block by
* rt_malloc. The released memory block is taken back to system heap.
*
* @param rmem the address of memory which will be released
*/
void rt_free(void *rmem)
{
struct heap_mem *mem;
RT_DEBUG_NOT_IN_INTERRUPT;
if (rmem == RT_NULL)
return;
RT_ASSERT((((rt_uint32_t)rmem) & (RT_ALIGN_SIZE-1)) == 0);
RT_ASSERT((rt_uint8_t *)rmem >= (rt_uint8_t *)heap_ptr &&
(rt_uint8_t *)rmem < (rt_uint8_t *)heap_end);
RT_OBJECT_HOOK_CALL(rt_free_hook, (rmem));
if ((rt_uint8_t *)rmem < (rt_uint8_t *)heap_ptr ||
(rt_uint8_t *)rmem >= (rt_uint8_t *)heap_end)
{
RT_DEBUG_LOG(RT_DEBUG_MEM, ("illegal memory\n"));
return;
}
/* Get the corresponding struct heap_mem ... */
mem = (struct heap_mem *)((rt_uint8_t *)rmem - SIZEOF_STRUCT_MEM);
RT_DEBUG_LOG(RT_DEBUG_MEM,
("release memory 0x%x, size: %d\n",
(rt_uint32_t)rmem,
(rt_uint32_t)(mem->next - ((rt_uint8_t *)mem - heap_ptr))));
/* protect the heap from concurrent access */
rt_sem_take(&heap_sem, RT_WAITING_FOREVER);
/* ... which has to be in a used state ... */
RT_ASSERT(mem->used);
RT_ASSERT(mem->magic == HEAP_MAGIC);
/* ... and is now unused. */
mem->used = 0;
mem->magic = 0;
if (mem < lfree)
{
/* the newly freed struct is now the lowest */
lfree = mem;
}
#ifdef RT_MEM_STATS
used_mem -= (mem->next - ((rt_uint8_t*)mem - heap_ptr));
#endif
/* finally, see if prev or next are free also */
plug_holes(mem);
rt_sem_release(&heap_sem);
}
/* 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;
}
/// Release a Semaphore
osStatus osSemaphoreRelease(osSemaphoreId semaphore_id)
{
rt_err_t result;
result = rt_sem_release(semaphore_id);
if (result == RT_EOK)
return osOK;
else
return osErrorOS;
}
/*********************************************************************************
*函数名称:void gps_fact_set( void )
*功能描述:格式化GPS定位数据存储区域
*输 入:none
*输 出:none
*返 回 值:none
*作 者:白养民
*创建日期:2013-12-01
*---------------------------------------------------------------------------------
*修 改 人:
*修改日期:
*修改描述:
*********************************************************************************/
void gps_fact_set(void)
{
u32 TempAddress;
rt_sem_take( &sem_dataflash, RT_TICK_PER_SECOND * FLASH_SEM_DELAY );
for( TempAddress = ADDR_DF_POSTREPORT_START; TempAddress < ADDR_DF_POSTREPORT_END; )
{
sst25_erase_4k( TempAddress );
TempAddress += 4096;
}
rt_sem_release( &sem_dataflash );
}
void put_forks(int i)
{
/* 进入临界区*/
rt_sem_take(&sem_lock, RT_WAITING_FOREVER);
phd_state[i] = THINKING;
test(LEFT_PHD(i));
test(RIGHT_PHD(i));
/* 退出临界区*/
rt_sem_release(&sem_lock);
}
static rt_size_t telnet_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
{
rt_size_t result;
/* read from rx ring buffer */
rt_sem_take(telnet->rx_ringbuffer_lock, RT_WAITING_FOREVER);
result = rb_get(&(telnet->rx_ringbuffer), buffer, size);
rt_sem_release(telnet->rx_ringbuffer_lock);
return result;
}
/**
* @brief status handler
*/
void StateHandler(void)
{
// gStatusFlag = TRUE;
// 保证信号量最多就为1，是一个二值信号量
if (sSemSystemTime.value == 0)
{
rt_sem_release(&sSemSystemTime);
}
}
/*
* This function will release the previously allocated memory page
* by rt_malloc_page.
*
* @param page_ptr the page address to be released.
* @param npages the number of page shall be released.
*
* @note this function is used for RT-Thread Application Module
*/
void rt_free_page(void *page_ptr, rt_size_t npages)
{
rt_page_free(page_ptr, npages);
/* update memory usage */
#ifdef RT_MEM_STATS
rt_sem_take(&heap_sem, RT_WAITING_FOREVER);
used_mem -= npages * RT_MM_PAGE_SIZE;
rt_sem_release(&heap_sem);
#endif
}
void test(int i)
{
if (phd_state[i] == HUNGRY &&
phd_state[LEFT_PHD(i)] != EATING &&
phd_state[RIGHT_PHD(i)] != EATING)
{
phd_state[i] = EATING;
/* 可以得到叉子，故发布信号量 */
rt_sem_release(&sem[i]);
}
}
