/*
 * 如果已缓存, 则更新;否则,当有空闲空间时,插入新数据;其他情况返回失败
 * */
int si_update_wl_collect_data(char *sn, union sinkinfo_ptc_ctc_st *data, rt_tick_t time_stamp)
{
	struct sinkinfo_wl_data_item_st *p;
	rt_err_t ret;

	if (NULL==sn || NULL==data) {
		printf_syn("func:%s(), param is NULL\n", __FUNCTION__);
		return FAIL;
	}

	if (NULL == sink_wl_collect_data) {
		printf_syn("func:%s(),  sink_wl_collect_data is NULL\n", __FUNCTION__);
		return FAIL;
	}

	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 SIE_FAIL;
	}

	sinki_debug_data(("func:%s(), line:%d, sn:%s\n", __FUNCTION__, __LINE__, sn));

	p = si_lookup_item_in_wl_data(sn);
	if (NULL != p) {
#if 0
		enum sink_data_dev_type_e dev_type;

		dev_type = si_get_dev_type(sn);
		if (SDDT_PT == dev_type) {
			rt_memcpy(&p->item.ptc_data, &data->ptc_data, sizeof(p->item.ptc_data));
		} else if (SDDT_PT == dev_type) {
			rt_memcpy(&p->item.ctc_data, &data->ctc_data, sizeof(p->item.ctc_data));
		} else {
			/* mark by David */
		}
#else
		rt_memcpy(&p->item, data, sizeof(p->item));
#endif
		p->time_stamp = time_stamp;
	} else {
		si_insert_item_to_wl_data(sn, data, time_stamp);
	}

	rt_sem_release(&sink_wl_data_sem);

	return SUCC;
}
Example #2
0
static rt_err_t rt_tetris_update_brick(rt_tetris_t* thiz)
{
	int index;

	RT_ASSERT(thiz != RT_NULL);

	index = (int)(7.0 * rand()/(RAND_MAX + 1.0)); 

	rt_memcpy(thiz->brick, thiz->next_brick, 4 * sizeof(rt_uint32_t));
	rt_memcpy(thiz->next_brick, g_brick[index], 4 * sizeof(rt_uint32_t));

	/* update next brick on view */
	thiz->view->update_next_brick(thiz->view, thiz);
		
	return RT_EOK;
}
/* draw raw hline */
static void framebuffer_draw_raw_hline(rt_uint8_t *pixels, int x1, int x2, int y)
{
	rt_uint8_t *dst;

	dst = GET_PIXEL(rtgui_graphic_get_device(), x1, y, rt_uint8_t);
	rt_memcpy(dst, pixels, (x2 - x1) * (rtgui_graphic_get_device()->bits_per_pixel/8));
}
Example #4
0
File: mq.c Project: amsl/RTGUI_NoOS
rt_err_t rt_mq_recv (rt_mq_t *mq, void* buffer, rt_size_t size)
{
	rt_err_t r;
	struct rt_mq_message *msg;

	/* mq is empty */
	if (mq->entry == 0)
	{
		return -RT_ETIMEOUT;
	}

	/* get message from queue */
	msg = (struct rt_mq_message*) mq->head;

	/* move message queue head */
	mq->head = msg->next;

	/* reach queue tail, set to NULL */
	if (mq->tail == msg) mq->tail = RT_NULL;

	/* decrease message entry */
	mq->entry --;

	/* copy message */
	rt_memcpy(buffer, msg + 1, size > mq->msg_size ? (mq->msg_size) : size);

	/* put message to free list */
	msg->next = (struct rt_mq_message*)mq->free;
	mq->free = msg;

	return RT_EOK;
}
Example #5
0
/***************************************************************************//**
* @brief
*   Configure OLED device
*
* @details
*
* @note
*
* @param[in] dev
*   Pointer to device descriptor
*
* @param[in] cmd
*   IIC control command
*
* @param[in] args
*   Arguments
*
* @return
*   Error code
******************************************************************************/
static rt_err_t miniStm32_oled_control(rt_device_t dev, int cmd, void *args)
{
	switch (cmd)
	{
	case RTGRAPHIC_CTRL_RECT_UPDATE:
//        miniStm32_oled_update((struct rt_device_rect_info *)args);
        oled_debug("OLED: update\n");
		break;
	case RTGRAPHIC_CTRL_POWERON:
		break;
	case RTGRAPHIC_CTRL_POWEROFF:
		break;
	case RTGRAPHIC_CTRL_GET_INFO:
	{
	    struct rt_device_graphic_info oled_info = {
            RTGRAPHIC_PIXEL_FORMAT_MONO,    // pixel_format
            1,                              // bits_per_pixel
            0,                              // reserved
            MINISTM32_OLED_WIDTH,           // width
            MINISTM32_OLED_HEIGHT,          // height
            RT_NULL                         // framebuffer
	    };
		rt_memcpy(args, &oled_info, sizeof(oled_info));
		break;
	}
	case RTGRAPHIC_CTRL_SET_MODE:
		break;
	}

	return RT_EOK;
}
Example #6
0
/* 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;
}
Example #7
0
struct rtgui_dc *rtgui_dc_buffer_create_from_dc(struct rtgui_dc* dc)
{
    struct rtgui_dc_buffer *buffer;

    if (dc == RT_NULL)
        return RT_NULL;

    if (dc->type == RTGUI_DC_BUFFER)
    {
        struct rtgui_dc_buffer *d = (struct rtgui_dc_buffer*) dc;

        /* buffer clone */
        buffer = (struct rtgui_dc_buffer*)rtgui_dc_buffer_create_pixformat(d->pixel_format,
                                                                           d->width,
                                                                           d->height);
        if (buffer != RT_NULL)
        {
            rt_memcpy(buffer->pixel, d->pixel, d->pitch * d->height);

            return RTGUI_DC(buffer);
        }
    }

    return RT_NULL;
}
Example #8
0
rt_err_t rtgui_recv_filter(rt_uint32_t type, rtgui_event_t *event, rt_size_t event_size)
{
	rtgui_event_t *e;
    struct rtgui_app *app;

    RT_ASSERT(event != RT_NULL);
    RT_ASSERT(event_size != 0);

    app = (struct rtgui_app *)(rt_thread_self()->user_data);
    if (app == RT_NULL)
        return -RT_ERROR;

	e = (rtgui_event_t*)&app->event_buffer[0];
    while (rt_mq_recv(app->mq, e, sizeof(union rtgui_event_generic), RT_WAITING_FOREVER) == RT_EOK)
    {
        if (e->type == type)
        {
            rt_memcpy(event, e, event_size);
            return RT_EOK;
        }
        else
        {
            if (RTGUI_OBJECT(app)->event_handler != RT_NULL)
            {
                RTGUI_OBJECT(app)->event_handler(RTGUI_OBJECT(app), e);
            }
        }
    }

    return -RT_ERROR;
}
/*
 * 将新数据插入到下标最小的空位置
 * */
static int si_insert_item_to_wl_data(char *sn, union sinkinfo_ptc_ctc_st *data, rt_tick_t time_stamp)
{
	int i;
	struct sinkinfo_wl_data_item_st *p;

	/* 查找是否已存储到缓冲区 */
	p = sink_wl_collect_data;
	for (i=0; i<SINKINFO_WL_DATA_ITEM_MAX_NO; ++i) {
		if ('\0' == p->pt_ct_sn[0])
			break;
		++p;
	}

	if (i < SINKINFO_WL_DATA_ITEM_MAX_NO) {
		rt_strncpy(p->pt_ct_sn, sn, sizeof(p->pt_ct_sn));
		rt_memcpy(&p->item, data, sizeof(p->item));
		p->time_stamp = time_stamp;

		sinki_debug_data(("func:%s(), inser data sn:%s\n", __FUNCTION__, sn));
	} else {
		printf_syn("func:%s(), wl-data-buffer is full\n", __FUNCTION__);
		return FAIL;
	}

	return SUCC;
}
Example #10
0
/** 
 *  @brief This function tells firmware to send a NULL data packet.
 *  
 *  @param priv     A pointer to wlan_private structure
 *  @param flags    Trasnit Pkt Flags
 *  @return 	    n/a
 */
int SendNullPacket(WlanCard *cardinfo, struct pbuf *packet, u8 flags)
{
	WlanCard *card = cardinfo;
	TxPD txpd;
	int ret = WLAN_STATUS_SUCCESS;
	u8 *ptr = card->TmpTxBuf;

	if (card->MediaConnectStatus == WlanMediaStateDisconnected)
	{
		ret = WLAN_STATUS_FAILURE;
		WlanDebug(WlanErr,"NULL packet wlan did not connect\r\n");
		goto done;
	}

	rt_memset(&txpd, 0, sizeof(TxPD));

	txpd.TxControl = card->PktTxCtrl;
	txpd.Flags = flags;
	txpd.Priority = WMM_HIGHEST_PRIORITY;
	txpd.TxPacketLocation = sizeof(TxPD);

	rt_memcpy(ptr, &txpd, sizeof(TxPD));

	ret = sbi_host_to_card(card, MVMS_DAT, card->TmpTxBuf, sizeof(TxPD));

	if (ret != 0)
	{
		WlanDebug(WlanErr,"TX Error: SendNullPacket failed!\n");
		goto done;
	}
	WlanDebug(WlanMsg,"Null data => FW\n");

done:
	return ret;
}
Example #11
0
int wlan_get_Mac_Address(WlanCard *cardinfo)
{

	WlanCard *card = cardinfo;
	HostCmd_DS_COMMAND *CmdPtr = NULL;
	HostCmd_DS_GET_HW_SPEC *hwspec;
	int ret = WLAN_STATUS_SUCCESS;

	rt_memset(card->MyMacAddress, 0xff, MRVDRV_ETH_ADDR_LEN);
	CmdPtr = rt_malloc(sizeof(HostCmd_DS_COMMAND));
	if (CmdPtr == NULL)
	{
		WlanDebug(WlanErr,"memory allocate failed for Get Mac\r\n");
		return WLAN_STATUS_FAILURE;

	}
	/* Set sequence number, command and INT option */
	card->SeqNum++;
	CmdPtr->SeqNum = card->SeqNum;
	CmdPtr->Command = HostCmd_CMD_GET_HW_SPEC;
	CmdPtr->Result = 0;
	hwspec = &CmdPtr->params.hwspec;
	CmdPtr->Size = sizeof(HostCmd_DS_GET_HW_SPEC) + S_DS_GEN;
	rt_memcpy(hwspec->PermanentAddr, card->MyMacAddress, MRVDRV_ETH_ADDR_LEN);

	ret = WlanExecuteCommand(cardinfo, CmdPtr);

	if (ret)
	{
		WlanDebug(WlanErr,"Falure for Get Mac\r\n");
		ret = WLAN_STATUS_FAILURE;
	}
	rt_free(CmdPtr);
	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;
}
Example #13
0
static rt_size_t rt_dram_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
{
    uint8_t *p;
    p = (uint8_t*)((uint32_t)DRAMStartAddr + pos * RAM_SECTOR_SIZE);
    rt_memcpy(p, buffer, size * RAM_SECTOR_SIZE);

	return size;
}
Example #14
0
int make_int32(char* ptr)
{
	int ret = 0;
	int temp = 0;//(short)*ptr;
	rt_memcpy((char*)&temp,(char*)ptr,4);
	ret = (int)ntohl((u_int)temp);
	return ret;
}
Example #15
0
short make_int16(char* ptr)
{
	short ret = 0;
	short temp = 0;//(short)*ptr;
	rt_memcpy((char*)&temp,(char*)ptr,2);
	ret = (short)ntohs((u_short)temp);
	return ret;
}
Example #16
0
int getForwardReply(int index,char* from, char* to,char* msg,int msgLen,send_data_t* sptr)
{
	int len=0,dlen=0;
	char* p=NULL;
	//dlen = 2*MAX_NAME_LEN+strlen(fdReplyStr)+msgLen;
	dlen = 2*MAX_NAME_LEN+msgLen;
	len = 1+2+2+4+4+1+dlen;
	
	if((len>sptr->data_len) || sptr->data_ptr==NULL)
	{
		p = (char*)rt_malloc(len);
		if(p==NULL)
		{
			return -1;
		}
		sptr->data_ptr = p;
		sptr->data_len = len;

		rt_memset(p,0,len);
	}
	else 
	{
		p = sptr->data_ptr;
		rt_memset(p,0,sptr->data_len);
	}
	
	*p = 0x02;
	p++;
	make_net16(p,0x0001);
	p+=2;
	make_net16(p,0x0004);
	p+=2;

	make_net32(p,index);
	p+=4;

	make_net32(p,dlen);
	p+=4;

	strcpy(p,to);
	p+=MAX_NAME_LEN;

	strcpy(p,from);
	p+=MAX_NAME_LEN;

/*	strcpy(p,fdReplyStr);
	p+=strlen(fdReplyStr);
*/
//	strcpy(p,msg);
	rt_memcpy(p,msg,msgLen);
	p+=msgLen;

	*p = 0x03;

	return len;
}
Example #17
0
/**
 * This function will duplicate a string.
 *
 * @param s the string to be duplicated
 *
 * @return the duplicated string pointer
 */
char *rt_strdup(const char *s)
{
	rt_size_t len = rt_strlen(s) + 1;
	char *tmp = (char *)rt_malloc(len);

	if (!tmp) return RT_NULL;

	rt_memcpy(tmp, s, len);
	return tmp;
}
Example #18
0
/* draw raw hline */
static void framebuffer_draw_raw_hline(rt_uint8_t *pixels, int x1, int x2, int y)
{
    struct rtgui_graphic_driver *drv;
    rt_uint8_t *dst;

    drv = rtgui_graphic_get_device();
    dst = GET_PIXEL(drv, x1, y, rt_uint8_t);
    rt_memcpy(dst, pixels,
              (x2 - x1) * _UI_BITBYTES(drv->bits_per_pixel));
}
void app_getGUID(void)
{
	unsigned int inparam[4]={54,0};
	unsigned int outparam[8]={0};
	iap_entry = (IAP)IAP_LOCATION;
	iap_entry(inparam,outparam);
	inparam[0]=58;
	iap_entry(inparam,outparam);
	rt_memcpy(devguid,outparam+1,sizeof(devguid));
}
Example #20
0
rt_err_t rt_mq_recv (rt_mq_t mq, void* buffer, rt_size_t size, rt_int32_t timeout)
{
	rt_err_t r;
	struct rt_mq_message *msg;

	SDL_SemWait(hmq->mutex);

	/* mq is empty */
	if (mq->entry == 0)
	{
		SDL_SemPost(hmq->mutex);

		if (timeout == RT_WAITING_FOREVER)
		{
			r = SDL_SemWait(hmq->msg);
		}
		else
		{
			r = SDL_SemWaitTimeout(hmq->msg, timeout * 10);
		}

		if (r != 0) return -RT_ERROR;

		SDL_SemWait(hmq->mutex);
	}
	else
	{
		/* take one message */
		SDL_SemWait(hmq->msg);
	}

	/* get message from queue */
	msg = (struct rt_mq_message*) mq->msg_queue_head;

	/* move message queue head */
	mq->msg_queue_head = msg->next;

	/* reach queue tail, set to NULL */
	if (mq->msg_queue_tail == msg) mq->msg_queue_tail = RT_NULL;

	/* copy message */
	rt_memcpy(buffer, msg + 1,
		size > mq->msg_size? (unsigned short)(mq->msg_size) : (unsigned short)size);

	/* put message to free list */
	msg->next = (struct rt_mq_message*)mq->msg_queue_free;
	mq->msg_queue_free = msg;

	/* decrease message entry */
	mq->entry --;

	SDL_SemPost(hmq->mutex);

	return RT_EOK;
}
Example #21
0
/**
 * Calc hardware version's Integer value
 */
void calc_hardware_version(void) {
    char const *start_addr = NULL;
    char *match_addr = NULL;
    char c_value[4] = { 0 };
    uint8_t c_length = 0, i = 0;

    start_addr = get_hardware_version();
    match_addr = rt_strstr((char *) start_addr, ".");
    while (match_addr != NULL) {
        c_length = match_addr - start_addr;
        rt_memcpy(c_value, start_addr, c_length);
        hardware_version[i++] = atoi(c_value);
        match_addr++;
        start_addr = match_addr;
        match_addr = rt_strstr((char *) start_addr, ".");
    }
    c_length = rt_strlen(start_addr);
    rt_memcpy(c_value, start_addr, c_length);
    hardware_version[i] = atoi(c_value);
}
Example #22
0
static void rt_hw_vector_copy(void)
{
	void *dst, *src;

	extern volatile rt_uint32_t Entry_Point;

	dst = (void*) (0xffff0000);
	src = (void*) (&Entry_Point);

	/* copy vector to 0xffff 0000 */
	rt_memcpy(dst, src, 64);
}
Example #23
0
static rt_size_t rt_uart_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
{
    int len;
    struct uart_device * uart_dev;
    _lock((struct uart_device *)dev);
    uart_dev = (struct uart_device*)dev;
    len = uart_dev->rx_len;
    rt_memcpy(buffer, uart_dev->rx_buf, len);
    uart_dev->rx_len = 0;
    _unlock((struct uart_device *)dev);
    return len;
}
/*
 * 获取电压、电流波形采样数据, 每个点是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;
}
Example #25
0
/* reception packet. */
struct pbuf *rt_dm9161_rx(rt_device_t dev)
{
	unsigned int temp_rx_bd,address;
	rt_uint32_t i = 0;
	rt_uint32_t length;
	unsigned char *p_recv;
	struct pbuf* p = RT_NULL;

	/* lock DM9000 device */
	rt_sem_take(&sem_lock, RT_WAITING_FOREVER);

	while (1)
	{
	
		address = MAC_TX_BD +  (MAX_TX_DESCR + i) * 8;
		temp_rx_bd = sep_emac_read(address);
	
		if (!(temp_rx_bd & 0x8000))
		{
			length = temp_rx_bd;
			length = length >> 16;

			p_recv = (unsigned char *)(ESRAM_BASE + (MAX_TX_DESCR + i) * 0x600);
			p = pbuf_alloc(PBUF_LINK,length,PBUF_RAM);
			if (p != RT_NULL)
			{
				struct pbuf *q;
				rt_int32_t len;

				for (q = p; q != RT_NULL; q = q->next)
				{
					rt_memcpy((rt_uint8_t *)(q->payload),p_recv,q->len);
				}
			}
			else
			{
				 rt_kprintf("Droping %d packet \n",length);
			}

			if(i == (MAX_RX_DESCR-1))
			{
				sep_emac_write(address,0xe000);
				i = 0;
			}
			else
			{
				sep_emac_write(address,0xc000);
				i++;
			}
		}
		else
			break;
Example #26
0
uint32_t coap_blockSize(coap_option_t *opt)
{
	coap_block_t block;
	uint32_t optLen = opt->len;
	uint32_t blockLen;

	rt_memcpy((&block + (3 - optLen)), opt->value, optLen);
	blockLen = block.szx << 4;

	LWIP_DEBUGF(COAP_DEBUG, ("block len: %i", blockLen));

	return blockLen;
}
Example #27
0
static void frame_client_create_package_data(rt_uint8_t *pkt_data, struct frame_format_em *frame, rt_uint8_t *data)
{
	rt_uint8_t *tx_pch;

	tx_pch = pkt_data;
	*tx_pch++ = frame->head1;
	*tx_pch++ = frame->head2;
	*tx_pch++ = frame->head3;
	*tx_pch++ = frame->head4;
	*tx_pch++ = frame->ctrl;
	*tx_pch++ = lwip_htons(frame->data_len) & 0xff;
	*tx_pch++ = lwip_htons(frame->data_len) >> 8;
	rt_memcpy(tx_pch, data, frame->data_len);
}
Example #28
0
rt_err_t rt_wlan_device_control(struct rt_wlan_device* device, rt_uint8_t cmd, void* arg)
{
    rt_err_t result;

    RT_ASSERT(device != RT_NULL);

    result = RT_EOK;
    switch (cmd)
    {
    case WLAN_CTRL_SET_SSID:
        RT_ASSERT(arg != RT_NULL);

        if (rt_strlen((char*)arg) >= SSID_NAME_MAX) result = -RT_ERROR;
        else
        {
            rt_strncpy(device->ssid, (char*)arg, SSID_NAME_MAX);
        }
        break;

    case WLAN_CTRL_SET_PASSWORD:
        RT_ASSERT(arg != RT_NULL);
        
        if (rt_strlen((char*)arg) >= PASSWORD_LENGTH_MAX) result = -RT_ERROR;
        else
        {
            rt_strncpy(device->password, (char*)arg, PASSWORD_LENGTH_MAX);
        }
        break;

    case WLAN_CTRL_SET_SECURITY:
        RT_ASSERT(arg != RT_NULL);
        device->security = *(rt_uint8_t*)arg;
        break;

    case WLAN_CTRL_SET_MODE:
        RT_ASSERT(arg != RT_NULL);
        device->mode = *(rt_uint8_t*)arg;
        break;

    case WLAN_CTRL_SET_CHANNEL:
        device->channel = *(rt_uint8_t*)arg;
        break;

	case WLAN_CTRL_SET_BSADDR:
		rt_memcpy(device->bs_addr, (rt_uint8_t*) arg, MAC_LENGTH_MAX);
		break;
    }
    
    return result;
}
Example #29
0
void rtgui_textbox_set_line_length(struct rtgui_textbox* box, rt_size_t length)
{
	rt_uint8_t* new_line;

	RT_ASSERT(box != RT_NULL);

	/* invalid length */
	if (length <= 0) return;

	new_line = rtgui_malloc(length);
	if (length < box->line_length)
	{
		rt_memcpy(new_line, box->text, length - 1);
		new_line[length] = '\0';
	}
	else
	{
		rt_memcpy(new_line, (const char*)box->text, rt_strlen((const char*)box->text));
	}

	/* set line length */
	box->line_length = length;
}
Example #30
0
struct rtgui_dc*
rtgui_graphic_driver_get_rect_buffer(const struct rtgui_graphic_driver *driver,
                                     struct rtgui_rect *r)
{
    int w, h;
    struct rtgui_dc_buffer *buffer;
    rt_uint8_t *pixel, *dst;
    struct rtgui_rect src, rect;

    /* use virtual framebuffer in default */
    if (driver == RT_NULL) driver = _current_driver;

    if (r == RT_NULL)
    {
        rtgui_graphic_driver_get_rect(driver, &rect);
    }
    else
    {
        rtgui_graphic_driver_get_rect(driver, &src);
        rect = *r;
        rtgui_rect_intersect(&src, &rect);
    }

    w = rtgui_rect_width (rect);
    h = rtgui_rect_height(rect);
    if (!(w && h) || driver->framebuffer == RT_NULL)
        return RT_NULL;

    /* create buffer DC */
    buffer = (struct rtgui_dc_buffer*)rtgui_dc_buffer_create_pixformat(driver->pixel_format, w, h);
    if (buffer == RT_NULL)
        return (struct rtgui_dc*)buffer;

    /* get source pixel */
    pixel = (rt_uint8_t*)driver->framebuffer
        + rect.y1 * driver->pitch
        + rect.x1 * rtgui_color_get_bpp(driver->pixel_format);

    dst = buffer->pixel;

    while (h--)
    {
        rt_memcpy(dst, pixel, buffer->pitch);

        dst += buffer->pitch;
        pixel += driver->pitch;
    }

    return (struct rtgui_dc*)buffer;
}