Пример #1
0
static void pw1_pid(void)
{
	rt_uint32_t key_value;
//	static double coefy2a = 0.8;
    
	while(1)
	{
		LCD_Clear();
		LCD_SetXY(0,0);     LCD_WriteString("=====sonic_test=====");
		LCD_SetXY(0, 1);    LCD_WriteString("1.front pid");
        LCD_SetXY(0, 2);    LCD_WriteString("2.f->pid");
        LCD_SetXY(0, 3);    LCD_WriteString("3.side pid");
        LCD_SetXY(0, 4);    LCD_WriteString("4.s->pid"); 
        LCD_SetXY(10, 1);   LCD_WriteString("5.fs pid");
		
		if(rt_mb_recv(&Mb_Key, &key_value, RT_WAITING_NO) == RT_EOK)
		{
			switch(key_value)
			{
				case key1:      pole_sonic(0x01);                break;
				case key2:      _input_pid(&sPos_Pid[eF_sonic]); break; 
                case key3:      pole_sonic(0x02);                break; 
                case key4:      _input_pid(&sPos_Pid[eS_sonic]); break;
                case key5:      pole_sonic(0x03);                break;
                case keyback:   return;
			}
		}
		Delay_ms(10);
	}
}
Пример #2
0
/* ethernet buffer */
void eth_tx_thread_entry(void* parameter)
{
	struct eth_tx_msg* msg;

	while (1)
	{
		if (rt_mb_recv(&eth_tx_thread_mb, (UInt32*)&msg, RT_WAITING_FOREVER) == RT_EOK)
 		{
			struct eth_device* enetif;

			assert(msg->netif != NULL);
			assert(msg->buf   != NULL);

			enetif = (struct eth_device*)msg->netif->state;
			if (enetif != NULL)
			{
				/* call driver's interface */
				if (enetif->eth_tx(&(enetif->parent), msg->buf) != RT_EOK)
				{
					printf("transmit eth packet failed\n");
				}
			}

			/* send ack */
			rt_sem_release(&(enetif->tx_ack));
		}
	}
}
Пример #3
0
/* Ethernet Tx Thread */
static void eth_tx_thread_entry(void* parameter)
{
    struct eth_tx_msg* msg;

    while (1)
    {
        if (rt_mb_recv(&eth_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)
                {
                    /* transmit eth packet failed */
                }
            }

            /* send ACK */
            rt_sem_release(&(enetif->tx_ack));
        }
    }
}
Пример #4
0
//打印在显示器上
void sys_Timer(void)
{
	rt_uint32_t key_value;
	
	while(1)
	{
		LCD_Clear();
		LCD_SetXY(0,0);
		LCD_WriteString("======Timer=======");
		LCD_SetXY(0,1);
		LCD_WriteString("M_TIME:");
		LCD_WriteDouble(M_TIME);
		LCD_SetXY(0,2);
		LCD_WriteString("S_TIME:");
		LCD_WriteDouble(S_TIME);
		LCD_SetXY(0,6);
		LCD_WriteString("1.Init_Timer");
		
		if(rt_mb_recv(&Mb_Key, &key_value, RT_WAITING_NO) == RT_EOK)
		{
			switch(key_value)
			{
				case key1:
					Init_Timer();
					break;
				case keyback:
					return;
			}
		}
		Delay_ms(1);
	}
}
Пример #5
0
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 );
}
Пример #6
0
static rt_err_t spi_wifi_transfer(struct spi_wifi_eth *dev)
{
    struct pbuf *p = RT_NULL;
    struct cmd_request cmd;
    struct response resp;

    rt_err_t result;
    const struct spi_data_packet *data_packet = RT_NULL;

    struct spi_wifi_eth *wifi_device = (struct spi_wifi_eth *)dev;
    struct rt_spi_device *rt_spi_device = wifi_device->rt_spi_device;

    spi_wifi_int_cmd(0);
    while (spi_wifi_is_busy());
    WIFI_DEBUG("sequence start!\n");

    memset(&cmd, 0, sizeof(struct cmd_request));
    cmd.magic1 = CMD_MAGIC1;
    cmd.magic2 = CMD_MAGIC2;

    cmd.flag |= CMD_FLAG_MRDY;

    result = rt_mb_recv(&wifi_device->spi_tx_mb,
                        (rt_uint32_t *)&data_packet,
                        0);
    if ((result == RT_EOK) && (data_packet != RT_NULL) && (data_packet->data_len > 0))
    {
        cmd.M2S_len = data_packet->data_len + member_offset(struct spi_data_packet, buffer);
        //WIFI_DEBUG("cmd.M2S_len = %d\n", cmd.M2S_len);
    }
Пример #7
0
struct pbuf *pcap_netif_rx(rt_device_t dev)
{
	struct pbuf* p = RT_NULL;

    rt_mb_recv(packet_mb, (rt_uint32_t*)&p, 0);

    return p;
}
Пример #8
0
/***********************************************************
* 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;
}
Пример #9
0
/*
 * 函数名: HallTest
 * 描  述: 
 * 输  入: 无
 * 输  出: 无
 * 调  用: 外部调用
 */
void HallTest(void)
{
	rt_uint32_t key_value;
	extern u8 Hall_Count;
	
	while(1)
	{
		LCD_Clear();
		LCD_SetXY(0,0);
		LCD_WriteString("========Hall========");
		LCD_SetXY(0,1);
		LCD_WriteString("1.SS_init");
		LCD_SetXY(0,2);
		LCD_WriteString("2.open hand_SS");
		LCD_SetXY(0,3);
		LCD_WriteString("3.leg_on");
		LCD_SetXY(0,4);
		LCD_WriteString("4.leg_off");
		LCD_SetXY(0,5);
		LCD_WriteString("5.open hand_SW");
		LCD_SetXY(0,6);
		LCD_WriteString("6.PW_init");
		LCD_SetXY(0,7);
		LCD_WriteInt(Hall_Count-1);

		if(rt_mb_recv(&Mb_Key, &key_value, RT_WAITING_NO) == RT_EOK)
		{
			switch(key_value)
			{
				case key1:
					Hall_Send(1);
					break;
				case key2:
					Hall_Send(2);	
					break;
				case key3:
					Hall_Send(3);
					break;
				case key4:
					Hall_Send(4);
					break;
				case key5:
					Hall_Send(5);
					break;
				case key6:
					Hall_Send(6);
					break;
				case keyback:
					return;
			}
		}
		Delay_ms(10);
	}
}
Пример #10
0
void sys_ImgSave(void)
{
	rt_uint32_t key_value;
	
	while(1)
	{
		LCD_Clear();
		LCD_SetXY(0,0);
		LCD_WriteString("======Img Save======");
		LCD_SetXY(0,1);
		LCD_WriteString("1.b_seesaw");
		LCD_SetXY(0,2);
		LCD_WriteString("2.b_polewalk");
    LCD_SetXY(0,3);
		LCD_WriteString("3.b_whitetape");
		LCD_SetXY(0,4);
		LCD_Printf("4.Handover");
		
		if(rt_mb_recv(&Mb_Key, &key_value, RT_WAITING_NO) == RT_EOK)
		{
			switch(key_value)
			{
        u8 res;
                
				case key1:
                    /* save image from camera1 ,file name is "b_seesaw.txt" */
                    res = Save_Img("b_seesaw", 1);
                    _show_res(res);
					break;
				
				case key2:
					res = Save_Img("b_polewalk", 4);
                    _show_res(res);
					break;
				
        case key3:
					res = Save_Img("b_whitetape", 2);
                    _show_res(res);
				  res = Save_Img("b_whitetape", 1);
                    _show_res(res);
					break;		
								
				case key4:
					res = Save_Img("Handover",5);
				            _show_res(res);
				  break;
				
				case keyback:
					return;
			}
		}
		Delay_ms(10);
	}
}
Пример #11
0
/* Ethernet Rx Thread */
static void eth_rx_thread_entry(void* parameter)
{
    struct eth_device* device;

    while (1)
    {
        if (rt_mb_recv(&eth_rx_thread_mb, (UInt32*)&device, RT_WAITING_FOREVER) == RT_EOK)
        {
            struct pbuf *p;

            /* check link status */
            if (device->link_changed)
            {
                int status;
                UInt32 level;

                level = rt_hw_interrupt_disable();
                status = device->link_status;
                device->link_changed = 0x00;
                rt_hw_interrupt_enable(level);

                if (status)
                    netifapi_netif_set_link_up(device->netif);
                else
                    netifapi_netif_set_link_down(device->netif);
            }

            /* receive all of buffer */
            while (1)
            {
                p = device->eth_rx(&(device->parent));
                if (p != NULL)
                {
                    /* notify to upper layer */
                    if( device->netif->input(p, device->netif) != ERR_OK )
                    {
                        LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: Input error\n"));
                        pbuf_free(p);
                        p = NULL;
                    }
                }
                else break;
            }
        }
        else
        {
            LWIP_ASSERT("Should not happen!\n",0);
        }
    }
}
Пример #12
0
/*
 * 函数名: RadarTest
 * 描  述: 激光雷达数据显示
 * 输  入: 无
 * 输  出: 无
 * 调  用: 外部调用
 */
void RadarTest(void)
{
	rt_uint32_t key_value;
	
	while(1)
	{
		LCD_Clear();
		LCD_SetXY(0,0);
		LCD_WriteString("=======Radar========");
		LCD_SetXY(0,1);
		LCD_Printf("%d",sonic_data[0].data);
		LCD_SetXY(10, 1);
		LCD_Printf("%d",sonic_data[0].count);
		LCD_SetXY(0,2);
		LCD_Printf("%d",sonic_data[3].data);
		LCD_SetXY(10,2);
		LCD_Printf("%d",sonic_data[3].count);
		
		if(rt_mb_recv(&Mb_Key, &key_value, RT_WAITING_NO) == RT_EOK)
		{
			switch(key_value)
			{
				case key1:
                    
					break;
				case key2:
					
					break;
				case key3:
                    
					break;
				case key4:
					
					break;
				case key5:
					
					break;
				case key6:
					
					break;
				case keyback:
					return;
				default:
					break;
			}
		}
		Delay_ms(10);
	}
}
Пример #13
0
/*
 * 函数名: LBTest
 * 描  述: 灯板测试函数
 * 输  入: 无
 * 输  出: 无
 * 调  用: 外部调用
 */
void LBTest(void)
{
	rt_uint32_t key_value;
	
	while(1)
	{
		LCD_Clear();
		LCD_SetXY(0,0);
		LCD_WriteString("=========LB=========");
		LCD_SetXY(0,1);
		LCD_WriteString("LB1:");
		LCD_WriteInt(LB_Count(1));
		LCD_SetXY(10,1);
		LCD_WriteString("LB2:");
		LCD_WriteInt(LB_Count(2));
		LCD_SetXY(0,2);
		LCD_WriteString("LB1:");
		LCD_Printf("%s",itob(LB_recv[0].v));
		LCD_SetXY(0,4);
		LCD_WriteString("LB2:");
		LCD_Printf("%s",itob(LB_recv[1].v));
		LCD_SetXY(0,6);
		LCD_WriteString("1.LB_Init");
		LCD_SetXY(10,6);
		LCD_WriteString("2.LB_State");
		LCD_SetXY(0,7);
		LCD_WriteString("3.LB_Test");
		
		if(rt_mb_recv(&Mb_Key, &key_value, RT_WAITING_NO) == RT_EOK)
		{
			switch(key_value)
			{
				case key1:
					LB_Init();
					break;
				case key2:
					LB_State();
					break;
				case key3:
					LB_Test();
					break;
				case keyback:
					return;
			}
		}
		Delay_ms(10);
	}
}
Пример #14
0
/** Wait for a new message to arrive in the mbox
 * @param mbox mbox to get a message from
 * @param msg pointer where the message is stored
 * @param timeout maximum time (in milliseconds) to wait for a message
 * @return 0 (milliseconds) if a message has been received
 *         or SYS_MBOX_EMPTY if the mailbox is empty
 */
u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
{
    int ret;

    ret = rt_mb_recv(*mbox, (rt_uint32_t *)msg, 0);

    if(ret == -RT_ETIMEOUT)
        return SYS_ARCH_TIMEOUT;
    else
    {
        if (ret == RT_EOK) 
            ret = 1;
    }

    return ret;
}
Пример #15
0
/*
 * 函数名: RecKin
 * 描  述: 测试 Kinect 接受
 * 输  入: 无
 * 输  出: 无
 * 调  用: 外部调用
 */
void RecKin_Print(void)
{
	rt_uint32_t key_value;
	
	while(1)
	{
		LCD_Clear();
		LCD_SetXY(0,0);
		LCD_WriteString("========Receiving========");
		LCD_SetXY(0,1);
		LCD_Printf("x = %d",(int)uart_data.x);
		LCD_SetXY(0,2);
		LCD_Printf("y = %d",(int)uart_data.y);
		LCD_SetXY(0,3);
		LCD_Printf("z = %d",(int)uart_data.z);
		LCD_SetXY(0,4);
		LCD_Printf("Now Angle:%g  %g  %g",Motor_Pos[W_MOTOR1_OLD_ID-W_MOTOR1_OLD_ID]*360,\
							Motor_Pos[W_MOTOR2_OLD_ID-W_MOTOR1_OLD_ID]*360,Motor_Pos[W_MOTOR3_OLD_ID-W_MOTOR1_OLD_ID]*360);
		LCD_SetXY(0,5);
		LCD_Printf("1.STOP %d %d %d",(int)(Motor_RealAim[W_MOTOR1_OLD_ID-W_MOTOR1_OLD_ID]*360/1000),\
							(int)(Motor_RealAim[W_MOTOR2_OLD_ID-W_MOTOR1_OLD_ID]*360/1000),(int)(Motor_RealAim[W_MOTOR3_OLD_ID-W_MOTOR1_OLD_ID]*360/1000));
		LCD_SetXY(0,7);
		LCD_WriteString("1.Set_XYZ");

		if(rt_mb_recv(&Mb_Key, &key_value, RT_WAITING_NO) == RT_EOK)
		{
			switch(key_value)
			{
				case key1:
					Input_DoubleValue(&uart_data.x,"x"); 
					Input_DoubleValue(&uart_data.y,"y");
					Input_DoubleValue(&uart_data.z,"z");
					Input_IntValue(&pos_speed.v_A,"v_A");
					Input_IntValue(&pos_speed.v_B,"v_B");
// 					Input_IntValue(&pos_speed.v_C,"v_C");
					Data_Processing();
 					W_MOTOR_OLD_FUNC(W_MOTOR2_OLD_ID, (float)pos_speed.pos_A , (int16_t)pos_speed.v_A , CMD_SET_PSG);
					W_MOTOR_OLD_FUNC(W_MOTOR2_OLD_ID, (float)pos_speed.pos_B , (int16_t)pos_speed.v_B , CMD_SET_PSG);
// 					W_MOTOR_OLD_FUNC(W_MOTOR3_OLD_ID, (float)pos_speed.pos_C , (int16_t)pos_speed.v_C , CMD_SET_PSG);
					break;
				case keyback:
					return;
			}
		}
		Delay_ms(10);
	}
}
Пример #16
0
/*
 * 函数名: DataBack
 * 描  述: 数据回传函数
 * 输  入: 无
 * 输  出: 无
 * 调  用: 外部调用
 */
void DataBackTest(void)
{
//	rt_uint32_t key_value;
	
	while(1)
	{
		
		LCD_Clear();
		LCD_SetXY(0,0);
		LCD_WriteString("======DataBack======");
		LCD_SetXY(0,1);
		
		#if DataBackEnable
		LCD_WriteString("DataNumber:");
		LCD_WriteInt(DataBack_GetCount());
		LCD_SetXY(0,2);
		LCD_WriteString("Press OK to send");
		
		if(rt_mb_recv(&Mb_Key, &key_value, RT_WAITING_NO) == RT_EOK)
		{
			switch(key_value)
			{
				case keyOK:
					LCD_Clear();
					LCD_SetXY(5,3);
					LCD_WriteString("Waiting...");
				
					DataBack_Write(DataBack_GetCount());
					DataBack_Send();
					Com_SendByte(2,'$');
				
					LCD_Clear();
					LCD_SetXY(7,3);
					LCD_WriteString("Done~!");
					Delay_ms(500);
					break;
				case keyback:
					return;
			}
		}
		#else 
			LCD_WriteString("Please Enable the   DataBack Function");
		#endif
		Delay_ms(10);
	}
}
Пример #17
0
void mmcsd_detect(void *param)
{
	struct rt_mmcsd_host *host;
	rt_uint32_t  ocr;
	rt_int32_t  err;

	while (1) 
	{
		if (rt_mb_recv(&mmcsd_detect_mb, (rt_uint32_t*)&host, RT_WAITING_FOREVER) == RT_EOK)
		{
			if (host->card == RT_NULL)
			{
				mmcsd_host_lock(host);
				mmcsd_power_up(host);
				mmcsd_go_idle(host);

				mmcsd_send_if_cond(host, host->valid_ocr);

				err = sdio_io_send_op_cond(host, 0, &ocr);
				if (!err) {
					if (init_sdio(host, ocr))
						mmcsd_power_off(host);
					mmcsd_host_unlock(host);
					continue;
				}

				/*
				 * detect SD card
				 */
				err = mmcsd_send_app_op_cond(host, 0, &ocr);
				if (!err) 
				{
					if (init_sd(host, ocr))
						mmcsd_power_off(host);
					mmcsd_host_unlock(host);
					continue;
				}
				mmcsd_host_unlock(host);
			}
		}
	}
}
Пример #18
0
/* ethernet buffer */
void eth_rx_thread_entry(void* parameter)
{
	struct eth_device* device;
	err_t err_ret;


	while (1) {
		if (rt_mb_recv(&eth_rx_thread_mb, (rt_uint32_t*)&device, RT_WAITING_FOREVER) == RT_EOK) {
			struct pbuf *p;
			/* check link status */
			if (device->link_changed) {
				int status;
				rt_uint32_t level;

				level = rt_hw_interrupt_disable();
				status = device->link_status;
				device->link_changed = 0x00;
				rt_hw_interrupt_enable(level);

				if (status)
					netifapi_netif_set_link_up(device->netif);
				else
					netifapi_netif_set_link_down(device->netif);
			}

			/* receive all of buffer */
			while (1) {
				p = device->eth_rx(&(device->parent));
				if (p != RT_NULL) {
					/* notify to upper layer */
					if( (err_ret=device->netif->input(p, device->netif)) != ERR_OK ) {
						printf_syn("ethernetif_input: Input error(%d)\n", err_ret);
						pbuf_free(p);
						p = NULL;
					}
				} else {
					break;
				}
			}
		}
	}
}
Пример #19
0
u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout)
{
	rt_err_t ret;
	s32_t t;
	u32_t tick;

	/* get the begin tick */
	tick = rt_tick_get();

	if(timeout == 0)
		t = RT_WAITING_FOREVER;
	else
	{
		/* convirt msecond to os tick */
		if (timeout < (1000/RT_TICK_PER_SECOND)) t = 1;
		else t = timeout / (1000/RT_TICK_PER_SECOND);
	}

	ret = rt_mb_recv(mbox, (rt_uint32_t *)msg, t);

	if(ret == -RT_ETIMEOUT) return SYS_ARCH_TIMEOUT;
	else if (ret == RT_EOK) ret = 1;

#if SYS_DEBUG
	{
		struct rt_thread *thread;
		thread = rt_thread_self();
	
		LWIP_DEBUGF(SYS_DEBUG, ("%s, Fetch mail: %s , 0x%x\n",thread->name,
			mbox->parent.parent.name, *(rt_uint32_t **)msg));
	}
#endif

	/* get elapse msecond */
	tick = rt_tick_get() - tick;

	/* convert tick to msecond */
	tick = tick * (1000/RT_TICK_PER_SECOND);
	if (tick == 0) tick = 1;

	return tick;
}
Пример #20
0
/** Wait for a new message to arrive in the mbox
 * @param mbox mbox to get a message from
 * @param msg pointer where the message is stored
 * @param timeout maximum time (in milliseconds) to wait for a message
 * @return time (in milliseconds) waited for a message, may be 0 if not waited
           or SYS_ARCH_TIMEOUT on timeout
 *         The returned time has to be accurate to prevent timer jitter!
 */
u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
{
    rt_err_t ret;
    s32_t t;
    u32_t tick;

    RT_DEBUG_NOT_IN_INTERRUPT;

    /* get the begin tick */
    tick = rt_tick_get();

    if(timeout == 0)
        t = RT_WAITING_FOREVER;
    else
    {
        /* convirt msecond to os tick */
        if (timeout < (1000/RT_TICK_PER_SECOND))
            t = 1;
        else
            t = timeout / (1000/RT_TICK_PER_SECOND);
    }

    ret = rt_mb_recv(*mbox, (rt_uint32_t *)msg, t);

    if(ret == -RT_ETIMEOUT)
        return SYS_ARCH_TIMEOUT;
    else
    {
        LWIP_ASSERT("rt_mb_recv returned with error!", ret == RT_EOK);
    }

    /* get elapse msecond */
    tick = rt_tick_get() - tick;

    /* convert tick to msecond */
    tick = tick * (1000 / RT_TICK_PER_SECOND);
    if (tick == 0)
        tick = 1;

    return tick;
}
Пример #21
0
void sys_sonic(void)
{
	rt_uint32_t key_value;
    
	while(1)
	{
		LCD_Clear();
		LCD_SetXY(0,0); LCD_WriteString("====pole_test====");
		LCD_SetXY(0, 1); LCD_WriteString("1.step1");
        LCD_SetXY(0, 2); LCD_WriteString("2.xypid");
        LCD_SetXY(0, 3); LCD_WriteString("3.pw1");
        LCD_SetXY(0, 4); LCD_WriteString("4.dis");
        
        LCD_SetXY(10, 1); LCD_WriteString("5.sd save");
        LCD_SetXY(10, 2); LCD_WriteString("6.");
        LCD_SetXY(10, 3); LCD_WriteString("7.");
        LCD_SetXY(10, 4); LCD_WriteString("8.");
		
		if(rt_mb_recv(&Mb_Key, &key_value, RT_WAITING_NO) == RT_EOK)
		{
			switch(key_value)
			{
				case key1:  _step1();       break;
				case key2:  pw1_pid();      break;
                case key3:  sonic_pw1();    break;
                case key4:  
                    Input_DoubleValue(&std_fdis, "f dis");    
                    Input_DoubleValue(&std_sdis, "s dis");
                case key5:
                {
                    int _sonicx = 0 ;
                    Input_IntValue(&_sonicx, "_sonicx");
                    sonic_SDsave(_sonicx, "sonic_data", 500);
                }  
                break;
                case keyback:               return;
			}
		}
		Delay_ms(10);
	}
}
Пример #22
0
u32_t sys_arch_mbox_tryfetch(sys_mbox_t mbox, void **msg)
{
	int ret;

	ret = rt_mb_recv(mbox, (rt_uint32_t *)msg, 0);

	if(ret == -RT_ETIMEOUT) return SYS_ARCH_TIMEOUT;
	else if (ret == RT_EOK) ret = 1;

#if SYS_DEBUG
	{
		struct rt_thread *thread;
		thread = rt_thread_self();
	
		LWIP_DEBUGF(SYS_DEBUG, ("%s, Fetch mail: %s , 0x%x\n",thread->name,
			mbox->parent.parent.name, *(rt_uint32_t **)msg));
	}
#endif

	return ret;
}
Пример #23
0
/*等待固定字符串的返回*/
rt_err_t gsm_wait_str( char *respstr, uint32_t timeout )
{
	rt_err_t		err;

	uint8_t			*pmsg;

	uint32_t		tick_start, tick_end;
	uint32_t		tm;
	__IO uint8_t	flag_wait = 1;

	tick_start	= rt_tick_get( );
	tick_end	= tick_start + timeout;
	tm			= timeout;

	while( flag_wait )
	{
		err = rt_mb_recv( &mb_gsmrx, (rt_uint32_t*)&pmsg, tm );
		if( err != -RT_ETIMEOUT )                           /*没有超时,判断信息是否正确*/
		{
			if( strstr( pmsg + 2, respstr ) != RT_NULL )    /*前两个字节为长度,找到了*/
			{
				rt_free( pmsg );                            /*释放*/
				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;
		}
	}
	return RT_ETIMEOUT;
}
Пример #24
0
/* 线程1入口 */
static void thread1_entry(void* parameter)
{
    char* str;
    
    while (1)
    {
        rt_kprintf("thread1: try to recv a mail\n");

        /* 从邮箱中收取邮件 */
        if (rt_mb_recv(&mb, (rt_uint32_t*)&str, RT_WAITING_FOREVER) == RT_EOK)
        {
            rt_kprintf("thread1: get a mail from mailbox, the content:%s\n", str);
            if (str == mb_str3)
                break;

            /* 延时10个OS Tick */
            rt_thread_delay(10);
        }
    }
    /* 执行邮箱对象脱离 */
    rt_mb_detach(&mb);
}
Пример #25
0
rt_err_t rtgui_send_sync(struct rtgui_app* app, rtgui_event_t *event, rt_size_t event_size)
{
    rt_err_t r;
    rt_int32_t ack_buffer, ack_status;
    struct rt_mailbox ack_mb;

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

    rtgui_event_dump(app, event);

    /* init ack mailbox */
    r = rt_mb_init(&ack_mb, "ack", &ack_buffer, 1, 0);
    if (r != RT_EOK)
        goto __return;

    event->ack = &ack_mb;
    r = rt_mq_send(app->mq, event, event_size);
    if (r != RT_EOK)
    {
        rt_kprintf("send sync event failed\n");
        goto __return;
    }

    r = rt_mb_recv(&ack_mb, (rt_uint32_t *)&ack_status, RT_WAITING_FOREVER);
    if (r != RT_EOK)
        goto __return;

    if (ack_status != RTGUI_STATUS_OK)
        r = -RT_ERROR;
    else
        r = RT_EOK;

__return:
    /* fini ack mailbox */
    rt_mb_detach(&ack_mb);
    return r;
}
Пример #26
0
void LookIt(void)
{
	rt_uint32_t key_value;
//	int i;
	
	while(1)
	{		
		LCD_Clear();
		LCD_SetXY(0,0);LCD_Printf("1.AngleSwing %d",AngleSwing);
		LCD_SetXY(0,1);LCD_Printf("2.AngleHit   %d",AngleHit);
		LCD_SetXY(0,2);LCD_Printf("3.pos_A      %f",pos_speed.pos_A);
		LCD_SetXY(0,3);LCD_Printf("4.pos_B      %f",pos_speed.pos_B);
		
		if(rt_mb_recv(&Mb_Key, &key_value, RT_WAITING_NO) == RT_EOK)
		{
            if(key_value == keyback)
            {
                return ;
            }
		}
		Delay_ms(10);
	}
}
Пример #27
0
rt_err_t rtgui_thread_send_sync(rt_thread_t tid, rtgui_event_t* event, rt_size_t event_size)
{
	rt_err_t r;
	struct rtgui_thread* thread;
	rt_int32_t ack_buffer, ack_status;
	struct rt_mailbox ack_mb;

	rtgui_event_dump(tid, event);

	/* init ack mailbox */
	r = rt_mb_init(&ack_mb, "ack", &ack_buffer, 1, 0);
	if ( r!= RT_EOK) goto __return;

	/* find rtgui_thread */
	thread = (struct rtgui_thread*) (tid->user_data);
	if (thread == RT_NULL){ r = RT_ERROR; goto __return; }

	event->ack = &ack_mb;
	r = rt_mq_send(thread->mq, event, event_size);
	if (r != RT_EOK) 
	{
		rt_kprintf("send sync event failed\n");
		goto __return;
	}

	r = rt_mb_recv(&ack_mb, (rt_uint32_t*)&ack_status, RT_WAITING_FOREVER);
	if ( r!= RT_EOK) goto __return;

	if (ack_status != RTGUI_STATUS_OK) r = -RT_ERROR;
	else r = RT_EOK;

	/* fini ack mailbox */
	rt_mb_detach(&ack_mb);

__return:
	return r;
}
Пример #28
0
/* ethernet buffer */
void eth_rx_thread_entry(void* parameter)
{
	struct eth_device* device;

	while (1)
	{
		if (rt_mb_recv(&eth_rx_thread_mb, (UInt32*)&device, RT_WAITING_FOREVER) == RT_EOK)
 		{
			struct pbuf *p;

			/* receive all of buffer */
			while (1)
			{
				p = device->eth_rx(&(device->parent));
				if (p != NULL)
				{
					/* notify to upper layer */
					eth_input(p, device->netif);
				}
				else break;
			}
		}
	}
}
Пример #29
0
void dfs_thread_entry(void* parameter)
{

   char *rev_meail;//定义指针,用来保存邮件内容	
  	/******************启动文件系统***************/
		/* init the device filesystem */
		dfs_init();
		elm_init();
		/* mount sd card fat partition 1 as root directory */
		if (dfs_mount("sd0", "/", "elm", 0, 0) == 0)
		{
			rt_kprintf("文件系统初始化成功!\n");
		}
		else
			rt_kprintf("文件系统初始化失败!\n");
	

	/*************************初始化LD3320***********************/
			ld3320_gpio_configuration();
			ld3320_nvic_cfg();
			ld3320_spi_init();
			LD_reset();
			nAsrStatus = LD_ASR_NONE;
			bMp3Play=0;
	
		if(wugege_read_ini(sys_ini_name)!=1)
				rt_kprintf("读取系统配置文件失败,语音识别将受到严重影响\n");
				rt_kprintf("读取系统配置文件成功\n");
		 if(PlayDemoSound_mp3(sys_shi_mp3)<0)
	   			rt_kprintf(" 播放初始化音乐失败,请确认是否能使用LD3320!\n");
		  		 rt_kprintf("播放初始化音乐成功!\n");
	 		rt_thread_delay(10);//延迟该线程10ms
			sys_wake=1;
			sys_wake_count=0;
  while(1)
  {
		  	if(RT_EOK==(rt_mb_recv(&mb,(rt_uint32_t*)&rev_meail,RT_WAITING_NO)))
		{
			
			rt_kprintf("接收到邮件,播放音乐%s\r\n",rev_meail);
					 if(PlayDemoSound_mp3(rev_meail)<0)
							rt_kprintf("播放音乐失败%s \r\n",rev_meail);
			rt_kprintf("接收到邮件,播放音乐完毕\r\n");
				//	 *rev_meail=NULL;
			nAsrStatus = LD_ASR_NONE;
		}
			rt_thread_delay(5);//延迟该线程5ms
			while(bMp3Play != 0)
				rt_thread_delay(5);
			switch (nAsrStatus)
			{
			case LD_ASR_RUNING:    //  LD3320芯片正在语音识别中
				break;
		
			case LD_ASR_ERROR:	   //  LD3320芯片发生错误
				break;
		
			case LD_ASR_NONE:	   //  LD3320芯片无动作
			{
				nAsrStatus=LD_ASR_RUNING;
				if (RunASR(sys_wake)==0)	//	启动一次ASR识别流程:ASR初始化,ASR添加关键词语,启动ASR运算
				{
					nAsrStatus = LD_ASR_ERROR;
				}
				break;
			}
			case LD_ASR_FOUNDOK:	//	LD3320芯片识别到语音
			{
	char mp3_name[25];	//mp3文件名缓冲区
	char action[15];
	char ini_name[20];
				int nAsrRes = LD_GetResult();	//	一次ASR识别流程结束,去取ASR识别结果
							if(nAsrRes==49)
							{
							sys_wake=1;
							sys_wake_count=0;
							PlayDemoSound_mp3(sys_shi_mp3);
							rt_kprintf("系统唤醒成功 \n"); 		
							}
							else if(sys_wake)
							{
							get_mps_ini_file(mp3_name,ini_name,action,nAsrRes);
							rt_kprintf("识别用户的mp3名字 %s 配置文件%s 命令%s 原始码%d\r\n",mp3_name,ini_name,action,nAsrRes);
							sys_wake_count=0;
							sys_wake=1;
							deal_action(action);
							 if(PlayDemoSound_mp3(mp3_name)<0)
							rt_kprintf("播放音乐失败%s \r\n",mp3_name);
							if(0!=strcmp(ini_name,sys_ini_name))
								{
									strcpy(sys_ini_name,ini_name);
									rt_kprintf("重新载入配置文件%s \r\n",sys_ini_name);
										if(wugege_read_ini(sys_ini_name)!=1)
									rt_kprintf("读取系统配置文件失败,语音识别将受到严重影响\r\n");
									}
							}
				rt_kprintf("\r\n识别到用户关键字为:%d \r\n",nAsrRes); 	
				nAsrStatus = LD_ASR_NONE;
				break;
			}
			case LD_ASR_FOUNDZERO: //无识别结果
				nAsrStatus = LD_ASR_NONE;
				break;
			default:
				nAsrStatus = LD_ASR_NONE;
				break;
			}
			}
  }
Пример #30
0
static void led3_thread_entry(void* parameter)
{
	
	rt_kprintf ( "\r\n led3_thread_entry!!\r\n");
    irmp_init();                                                            // initialize irmp
	  irsnd_init();        
    timer2_init();                                                          // initialize timer2
	rt_kprintf ( "\r\n 红外收发系统初始化完成!\r\n");
    for (;;)
    {
			char *str;
		//	rt_kprintf ( "IRMP  is going!!!\r\n");
			 rt_thread_delay(1);
			if(RT_EOK== (rt_mb_recv(&dfs_mb,(rt_uint32_t*)&str,RT_WAITING_NO)))
			{rt_kprintf("接收到控制邮件,数据为 %s",str);
				//   TIM_Cmd(TIM2, ENABLE);
							if(strcmp(str,"getremote")==0)
								hot_remote_state=1;
								if(strcmp(str,"sendremote")==0)	
									hot_remote_send=1;
			}
        if (irmp_get_data (&irmp_data))
        {
          rt_kprintf("接收红外信号编码方式: %s",irmp_protocol_names[irmp_data.protocol]);
          rt_kprintf(" 编码地址: 0x%2X",irmp_data.address);
          rt_kprintf(" 命令: 0x%2X",irmp_data.command);
          rt_kprintf(" 标志位: 0x%2X\r\n",irmp_data.flags );
			if(1==hot_remote_state)	
			{
			hot_remote_state=2;
			irmp_data1=irmp_data;
			rt_mb_send(&mb,(rt_uint32_t)get_remot1_mp3);//发送邮件
				 rt_kprintf("红外接收完成第一次\n" );
			}
		else if(2==hot_remote_state)
			{
			if(irmp_data1.command==irmp_data.command)
				{
					 rt_kprintf("红外接收完成第二次,验证通过\n" );
				rt_mb_send(&mb,(rt_uint32_t)get_remot2_mp3);//发送邮件
				hot_remote_state=0;
					//  TIM_Cmd(TIM2, DISABLE);
				}
			else {
				 rt_kprintf("红外接收完成第二次,验证不通过,再次接收红外数据\n" );
				rt_mb_send(&mb,(rt_uint32_t)check_fail_mp3);//发送邮件
				hot_remote_state=1;
				}
			}
        }
				if(hot_remote_send)	
		{   
		hot_remote_send=0;
		//	 TIM_Cmd(TIM2, ENABLE);
			/*	irmp_data.protocol = IRMP_SAMSUNG32_PROTOCOL;                             // use NEC protocol
        irmp_data.address  = 0x0e0e;                                        // set address to 0x00FF
        irmp_data.command  = 0xf30c;                                        // set command to 0x0001
        irmp_data.flags    = 0;                                             // don't repeat frame*/
        irsnd_send_data (&irmp_data, TRUE);                                 // send frame, wait for completion			// don't repeat frame
			rt_mb_send(&mb,(rt_uint32_t)sen_remot_mp3);
		  rt_kprintf("发送红外数据完成\n");
		  rt_kprintf("发射红外信号编码方式: %s",irmp_protocol_names[irmp_data.protocol]);
          rt_kprintf(" 编码地址: 0x%2X",irmp_data.address);
          rt_kprintf(" 命令: 0x%2X",irmp_data.command);
          rt_kprintf(" 标志位: 0x%2X\r\n",irmp_data.flags );
		//  TIM_Cmd(TIM2, DISABLE);
		}
    }
}