Пример #1
0
void test_mutex3(void * pParam) 
{	
	
	while(1) {
		
		raw_mutex_get(&mutext1, RAW_WAIT_FOREVER);
		raw_mutex_get(&mutext1, RAW_WAIT_FOREVER);

		vc_port_printf("test_mutex3\n");

		raw_sleep(RAW_TICKS_PER_SECOND*2);
		vc_port_printf("test_mutex333333\n");
		raw_mutex_put(&mutext1);
		raw_mutex_put(&mutext1);
		
	}
}
Пример #2
0
/*
************************************************************************************************************************
*                                       Activate  the specified timer
*
* Description: This function is called to activate  the specified timer
*
* Arguments  :timer_ptr is the address of this timer object
*                    -----
*                
*				         
*				         
* Returns   RAW_TIMER_STATE_INVALID:  means timer is already active or timer is deleted..
*				   RAW_SUCCESS: means timer activate success
* Note(s)    :RAW_STATE_UNKNOWN wrong task state, probally sysytem error.
*
*             
************************************************************************************************************************
*/
RAW_U16 raw_timer_activate(RAW_TIMER *timer_ptr, RAW_VOID *expiration_input)
{
	RAW_U16 position;
	RAW_U16 mutex_ret;
	
	#if (RAW_TIMER_FUNCTION_CHECK > 0)
	
	if (timer_ptr == 0) {
		return RAW_NULL_OBJECT;
	}

	if (raw_int_nesting) {

		return RAW_NOT_CALLED_BY_ISR;
		
	}

	
	#endif

	if (timer_ptr->object_type != RAW_TIMER_OBJ_TYPE) {

		return RAW_ERROR_OBJECT_TYPE;
	}
	
	/*Timer state TIMER_ACTIVE TIMER_DELETED is not allowed to delete*/
	if (timer_ptr->timer_state == TIMER_ACTIVE) {
		
		return RAW_TIMER_STATE_INVALID;	
	}

	if (timer_ptr->timer_state == TIMER_DELETED) {
		
		return RAW_TIMER_STATE_INVALID;
	}

	timer_ptr->raw_timeout_param = expiration_input;
	
	mutex_ret = raw_mutex_get(&timer_mutex, RAW_WAIT_FOREVER);
	RAW_ASSERT(mutex_ret == RAW_SUCCESS);
		
	timer_ptr->match  = raw_timer_count + timer_ptr->init_count;
	position   = (RAW_U16)(timer_ptr->match & (TIMER_HEAD_NUMBERS - 1) );
	/*Sort by remain time*/
	timer_ptr->remain = timer_ptr->init_count;
	/*Used by timer delete*/
	timer_ptr->to_head = &timer_head[position];
	
	timer_list_priority_insert(&timer_head[position], timer_ptr);
	timer_ptr->timer_state = TIMER_ACTIVE;
	raw_mutex_put(&timer_mutex);

	return RAW_SUCCESS;
}
Пример #3
0
RAW_VOID raw_free(void *ptr)
{
	MACB	*macb =  &malloc_macb;
	
	if (raw_int_nesting) {

		return;

	}

	raw_mutex_get(&macb->mem_lock, RAW_WAIT_FOREVER);
	_mem_free(ptr, macb);
	raw_mutex_put(&macb->mem_lock);

}
Пример #4
0
RAW_VOID *raw_malloc(RAW_U32 size)
{
	RAW_VOID *addr;
	MACB	*macb =  &malloc_macb;
	
	if (raw_int_nesting) {

		return 0;

	}

	raw_mutex_get(&macb->mem_lock, RAW_WAIT_FOREVER);
	addr = _mem_malloc(size, macb);
	raw_mutex_put(&macb->mem_lock);
	
	return addr;

}
Пример #5
0
RAW_OS_ERROR raw_timer_deactivate(RAW_TIMER *timer_ptr)
{
	RAW_OS_ERROR mutex_ret;
	
	#if (RAW_TIMER_FUNCTION_CHECK > 0)
	
	if (timer_ptr == 0) {
		return RAW_NULL_OBJECT;
	}

	if (raw_int_nesting) {

		return RAW_NOT_CALLED_BY_ISR;
		
	}
	
	#endif

	if (timer_ptr->object_type != RAW_TIMER_OBJ_TYPE) {

		return RAW_ERROR_OBJECT_TYPE;
	}
	
	/*Timer state TIMER_DEACTIVE  TIMER_DELETED is not allowed to delete*/
	if (timer_ptr->timer_state == TIMER_DEACTIVE) {
		return RAW_TIMER_STATE_INVALID;
	}
	
	if (timer_ptr->timer_state == TIMER_DELETED) {
		return RAW_TIMER_STATE_INVALID;

	}
	
	mutex_ret = raw_mutex_get(&timer_mutex, RAW_WAIT_FOREVER);
	RAW_ASSERT(mutex_ret == RAW_SUCCESS);
	
	timer_list_remove(timer_ptr);
	timer_ptr->timer_state = TIMER_DEACTIVE;
	raw_mutex_put(&timer_mutex);
	
	return RAW_SUCCESS;

}
Пример #6
0
RAW_OS_ERROR raw_timer_change(RAW_TIMER *timer_ptr, RAW_TICK_TYPE initial_ticks, RAW_TICK_TYPE reschedule_ticks)
{
	RAW_OS_ERROR mutex_ret;
	
	#if (RAW_TIMER_FUNCTION_CHECK > 0)
	
	if (timer_ptr == 0) {
		return RAW_NULL_OBJECT;
	}


	if (raw_int_nesting) {

		return RAW_NOT_CALLED_BY_ISR;
		
	}
	
	#endif

	if (timer_ptr->object_type != RAW_TIMER_OBJ_TYPE) {

		return RAW_ERROR_OBJECT_TYPE;
	}
	
	
	/*Only timer state TIMER_DEACTIVE is  allowed here*/	
	if (timer_ptr->timer_state != TIMER_DEACTIVE) {
		return RAW_TIMER_STATE_INVALID;
	}
	
	if (timer_ptr->timer_state == TIMER_DELETED) {
		return RAW_TIMER_STATE_INVALID;
	}
	
	mutex_ret = raw_mutex_get(&timer_mutex, RAW_WAIT_FOREVER);
	RAW_ASSERT(mutex_ret == RAW_SUCCESS);
	
	timer_ptr->init_count = initial_ticks;
	timer_ptr->reschedule_ticks = reschedule_ticks;
	raw_mutex_put(&timer_mutex);
	
	return RAW_SUCCESS;
}
Пример #7
0
void test_mutex1(void * pParam) 
{	
	
	raw_mutex_create(&mutext1, (RAW_U8 *)"mutex1", RAW_MUTEX_INHERIT_POLICY, 0);
	//raw_mutex_create(&mutext1, (RAW_U8 *)"mutex1", RAW_MUTEX_CEILING_POLICY, 9);
	//raw_mutex_create(&mutext1, (RAW_U8 *)"mutex1", RAW_MUTEX_NONE_POLICY, 9);
	
	while(1)
	{		
		
		raw_sleep(RAW_TICKS_PER_SECOND);

		vc_port_printf("..............................\n");
		
		raw_mutex_get(&mutext1, 2);
		vc_port_printf("test_mutex1\n");
		
		raw_mutex_put(&mutext1);
		
	}
}
Пример #8
0
/*
************************************************************************************************************************
*                                    Timer task 
*
* Description: This function is called to  start a timer task.
*
* Arguments  :pa is the parameters to task.
*                    -----
*                
*				         
*				         
* Returns   
*				   
* Note(s) :This function is called by internal, users shoud not touch this function.
*
*             
************************************************************************************************************************
*/
void timer_task(void *pa) 
{
	LIST 								*timer_head_ptr;
	LIST 								*iter;
	LIST 								*iter_temp;
	RAW_TIMER							*timer_ptr;
	RAW_OS_ERROR                         mutex_ret;
	RAW_U16                              callback_ret;
	
	/*reset the timer_sem count since it may not be 0 at this point, make it start here*/
	raw_semaphore_set(&timer_sem, 0);
	pa = pa;
	
	while (1) {
		
		/*timer task will be blocked after call this function*/
		raw_semaphore_get(&timer_sem, RAW_WAIT_FOREVER);

		mutex_ret = raw_mutex_get(&timer_mutex, RAW_WAIT_FOREVER);
		RAW_ASSERT(mutex_ret == RAW_SUCCESS);

		/*calculate which  timer_head*/
		raw_timer_count++;                                          
	
		timer_head_ptr  = &timer_head;

		iter = timer_head_ptr->next;
		
		while (RAW_TRUE) {

			/*if timer exits*/	
			if (iter != timer_head_ptr) {

				/*Must use iter_temp because iter may be remove later.*/
				iter_temp = iter->next;
				timer_ptr =  raw_list_entry(iter, RAW_TIMER, timer_list);

				/*if timeout*/
				if (raw_timer_count == timer_ptr->match) {  

					/*remove from timer list*/
					timer_list_remove(timer_ptr);

					/*if timer is reschedulable*/			
					if (timer_ptr->reschedule_ticks) {

						/*Sort by remain time*/
						timer_ptr->remain = timer_ptr->reschedule_ticks;

						timer_ptr->match  = raw_timer_count + timer_ptr->remain;
						timer_ptr->to_head = &timer_head;
						timer_list_priority_insert(&timer_head, timer_ptr);
					          
					} 

					else {

						timer_ptr->timer_state = TIMER_DEACTIVE;

					}

					/*Any way both condition need to call registered timer function*/
					/*the registered timer function should not touch any timer related API,otherwise system will be crashed*/
					if (timer_ptr->raw_timeout_function) {

						callback_ret = timer_ptr->raw_timeout_function(timer_ptr->raw_timeout_param);
						if ((callback_ret == TIMER_CALLBACK_STOP) && (timer_ptr->timer_state != TIMER_DEACTIVE)) {
							/*remove from timer list*/
							timer_list_remove(timer_ptr);
							timer_ptr->timer_state = TIMER_DEACTIVE;
						}
					         
					}

					iter  = iter_temp; 

				} 

				else { 

					break;	
				}

			}

			/*exit because timer is not exit*/		
			else {

				break;
			}

		}

		raw_mutex_put(&timer_mutex);

	}


}
Пример #9
0
void simple_printf_unlock(void)
{

    raw_mutex_put(&mutex_printf_obj);

}