Beispiel #1
0
void tx_application_define(void *first_unused_memory)
{

	CHAR *pool_pointer;


	/* Create a byte memory pool from which to allocate
	the thread stacks. */
	tx_byte_pool_create(&my_byte_pool, "my_byte_pool",
		first_unused_memory,
		DEMO_BYTE_POOL_SIZE);

	/* Put system definition stuff in here, e.g., thread
	creates and other assorted create information. */

	/* Allocate the stack for the Speedy_Thread. */
	tx_byte_allocate(&my_byte_pool, (VOID **) &pool_pointer,
		DEMO_STACK_SIZE, TX_NO_WAIT);

	/* Create the Speedy_Thread. */
	tx_thread_create(&Speedy_Thread, "Speedy_Thread",
		Speedy_Thread_entry, 0,
		pool_pointer, DEMO_STACK_SIZE, 5, 5,
		TX_NO_TIME_SLICE, TX_AUTO_START);

	/* Allocate the stack for the Slow_Thread. */
	tx_byte_allocate(&my_byte_pool, (VOID **) &pool_pointer,
		DEMO_STACK_SIZE, TX_NO_WAIT);

	/* Create the Slow_Thread. */
	tx_thread_create(&Slow_Thread, "Slow_Thread",
		Slow_Thread_entry, 1, pool_pointer,
		DEMO_STACK_SIZE, 15, 15,
		TX_NO_TIME_SLICE, TX_AUTO_START);

	/* Create the mutex used by both threads */
	tx_mutex_create(&my_mutex, "my_mutex", TX_NO_INHERIT);


}
STATUS FF_Sim_Device::Open(FF_Mem *p_mem)
{
	// When simulating with memory, we must not initialize
	// the device twice; otherwise we will wipe out our memory.
	if (FT_device_initialized)
		return OK;

	FT_device_initialized = 1;

	// Initialize the interrupt service routine.
	Status status = FF_ISR_Open(p_mem, &Interrupt_Callback);
	if (status != OK)
		return status;
		
	// Initialize the watchdog routine.
	status = FF_watchdog.Open(p_mem, Flash_Address::Num_Units() );
	if (status != OK)
		return status;
		
	// We need to initialize the device before we can ask it how many
	// device blocks it has, so Flash_Address has not been initialized.
	//U32 num_bytes = Flash_Address::Num_Units() * Flash_Address::Pages_Per_Unit() * Flash_Address::Bytes_Per_Page();
	U32 num_bytes = SIM_NUM_UNITS * SIM_PAGES_PER_UNIT * SIM_BYTES_PER_PAGE;

#ifndef _WINDOWS
#ifdef THREADX
    // Allocate memory for simulating file system.
    STATUS status = tx_byte_allocate(&System_Memory, (void **)&p_mem_file, num_bytes, TX_WAIT_FOREVER);
#else
    // Allocate memory for simulating file system.
    STATUS status = NU_Allocate_Memory(&System_Memory, (void **)&p_mem_file, num_bytes, NU_NO_SUSPEND);
#endif
	if (status != OK)
	{
		CT_Log_Error(CT_ERROR_TYPE_FATAL,
			"Initialize_Test", 
			"Allocate memory failed",
			status,
			0);
	}
#else
	p_mem_file = (char*)FT_p_mem_file;
#endif
	p_mem_file_last = p_mem_file + num_bytes;
	
	// Set file to all erased.
	memset(p_mem_file, 0XFF, num_bytes);

	Set_Bad_Spots();
	return OK;
}
Beispiel #3
0
Datei: demo.c Projekt: igou/tx
void    tx_application_define(void *first_unused_memory)
{

CHAR    *pointer;


    /* Create a byte memory pool from which to allocate the thread stacks.  */
    tx_byte_pool_create(&byte_pool_0, "byte pool 0", first_unused_memory, DEMO_BYTE_POOL_SIZE);

    /* Put system definition stuff in here, e.g. thread creates and other assorted
       create information.  */

    /* Allocate the stack for thread 0.  */
    tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);

    /* Create the main thread.  */
    tx_thread_create(&thread_0, "thread 0", thread_0_entry, 0,  
            pointer, DEMO_STACK_SIZE, 
            1, 1, TX_NO_TIME_SLICE, TX_AUTO_START);


    /* Allocate the stack for thread 1.  */
    tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);

    /* Create threads 1 and 2. These threads pass information through a ThreadX 
       message queue.  It is also interesting to note that these threads have a time
       slice.  */
    tx_thread_create(&thread_1, "thread 1", thread_1_entry, 1,  
            pointer, DEMO_STACK_SIZE, 
            16, 16, 4, TX_AUTO_START);

    /* Allocate the stack for thread 2.  */
    tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);

    tx_thread_create(&thread_2, "thread 2", thread_2_entry, 2,  
            pointer, DEMO_STACK_SIZE, 
            16, 16, 4, TX_AUTO_START);

    /* Allocate the stack for thread 3.  */
    tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);

    /* Create threads 3 and 4.  These threads compete for a ThreadX counting semaphore.  
       An interesting thing here is that both threads share the same instruction area.  */
    tx_thread_create(&thread_3, "thread 3", thread_3_and_4_entry, 3,  
            pointer, DEMO_STACK_SIZE, 
            8, 8, TX_NO_TIME_SLICE, TX_AUTO_START);

    /* Allocate the stack for thread 4.  */
    tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);

    tx_thread_create(&thread_4, "thread 4", thread_3_and_4_entry, 4,  
            pointer, DEMO_STACK_SIZE, 
            8, 8, TX_NO_TIME_SLICE, TX_AUTO_START);

    /* Allocate the stack for thread 5.  */
    tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);

    /* Create thread 5.  This thread simply pends on an event flag which will be set
       by thread_0.  */
    tx_thread_create(&thread_5, "thread 5", thread_5_entry, 5,  
            pointer, DEMO_STACK_SIZE, 
            4, 4, TX_NO_TIME_SLICE, TX_AUTO_START);

    /* Allocate the stack for thread 6.  */
    tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);

    /* Create threads 6 and 7.  These threads compete for a ThreadX mutex.  */
    tx_thread_create(&thread_6, "thread 6", thread_6_and_7_entry, 6,  
            pointer, DEMO_STACK_SIZE, 
            8, 8, TX_NO_TIME_SLICE, TX_AUTO_START);

    /* Allocate the stack for thread 7.  */
    tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_STACK_SIZE, TX_NO_WAIT);

    tx_thread_create(&thread_7, "thread 7", thread_6_and_7_entry, 7,  
            pointer, DEMO_STACK_SIZE, 
            8, 8, TX_NO_TIME_SLICE, TX_AUTO_START);

    /* Allocate the message queue.  */
    tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_QUEUE_SIZE*sizeof(ULONG), TX_NO_WAIT);

    /* Create the message queue shared by threads 1 and 2.  */
    tx_queue_create(&queue_0, "queue 0", TX_1_ULONG, pointer, DEMO_QUEUE_SIZE*sizeof(ULONG));

    /* Create the semaphore used by threads 3 and 4.  */
    tx_semaphore_create(&semaphore_0, "semaphore 0", 1);

    /* Create the event flags group used by threads 1 and 5.  */
    tx_event_flags_create(&event_flags_0, "event flags 0");

    /* Create the mutex used by thread 6 and 7 without priority inheritance.  */
    tx_mutex_create(&mutex_0, "mutex 0", TX_NO_INHERIT);

    /* Allocate the memory for a small block pool.  */
    tx_byte_allocate(&byte_pool_0, (VOID **) &pointer, DEMO_BLOCK_POOL_SIZE, TX_NO_WAIT);

    /* Create a block memory pool to allocate a message buffer from.  */
    tx_block_pool_create(&block_pool_0, "block pool 0", sizeof(ULONG), pointer, DEMO_BLOCK_POOL_SIZE);

    /* Allocate a block and release the block memory.  */
    tx_block_allocate(&block_pool_0, (VOID **) &pointer, TX_NO_WAIT);

    /* Release the block back to the pool.  */
    tx_block_release(pointer);
}