void main_task
(
uint_32 initial_data
)
{
ENTRY_STRUCT entry;
_mqx_uint result;
_mqx_uint i;
uchar c;
/* Create the log component */
result = _log_create_component();
if (result != MQX_OK) {
printf("Main task: _log_create_component failed");
_task_block();
}
/* Create a log */
result = _log_create(MY_LOG,
10 * (sizeof(ENTRY_STRUCT)/sizeof(_mqx_uint)), 0);
if (result != MQX_OK) {
printf("Main task: _log_create failed");
_task_block();
}
/* Write the data to the log */
printf("Please type in 10 characters:\n");
for (i = 0; i < 10; i++) {
c = getchar();
result = _log_write(MY_LOG, 2, (_mqx_uint)c, i);
if (result != MQX_OK) {
printf("Main task: _log_write failed");
}
}
/* Read data from the log */
printf("\nLog contains:\n");
while (_log_read(MY_LOG, LOG_READ_OLDEST_AND_DELETE, 2,
(LOG_ENTRY_STRUCT_PTR)&entry) == MQX_OK)
{
printf("Time: %lu.%03u%03u, c=%c, i=%u\n",
entry.HEADER.SECONDS,
(_mqx_uint)entry.HEADER.MILLISECONDS,
(_mqx_uint)entry.HEADER.MICROSECONDS,
(uchar)entry.C & 0xff,
entry.I);
}
/* Destroy the log */
_log_destroy(MY_LOG);
_task_block();
}
void main_task
(
uint_32 parameter
)
{
MESSAGE_HEADER_STRUCT_PTR msg_ptr;
_task_id created_task;
_mqx_uint log_result;
_mqx_uint event_result;
_mqx_uint sem_result;
_int_install_unexpected_isr();
printf("\nMQX %s\n",_mqx_version);
printf("Hello from main_task().\n");
/* create the log component */
log_result = _log_create_component();
if (log_result != MQX_OK) {
/* log component could not be created */
} /* endif */
/* Create the mutex component */
if (_mutex_create_component() != MQX_OK) {
/* an error has been detected */
}
/* create the event component */
event_result = _event_create_component(EVENT_INITIAL_NUMBER, EVENT_GROWTH,
EVENT_MAXIMUM);
if (event_result != MQX_OK) {
/* event component could not be created */
printf("Error: Cannot create event component\n");
_task_block();
} /* endif */
/* create the semaphore component */
sem_result = _sem_create_component(SEM_INITIAL_NUMBER, SEM_GROWTH,
SEM_MAXIMUM);
if (sem_result != MQX_OK) {
/* semaphore component could not be created */
printf("Error: Cannot create semaphore component\n");
_task_block();
} /* endif */
MsgPool_pool_id = _msgpool_create ( 8, 10, 0, 0);
if (MsgPool_pool_id == MSGPOOL_NULL_POOL_ID) {
/* _msgpool_create did not succeed */
printf("Error: Cannot create message pool\n");
_task_block();
}
Main_Queue_qid = _msgq_open( MSGQ_FREE_QUEUE, SIZE_UNLIMITED);
if (Main_Queue_qid == (_queue_id)0){
/* queue could not be opened */
printf("Error: Cannot open message pool\n");
_task_block();
}
created_task = _task_create(0, SENDER, 0);
if (created_task == MQX_NULL_TASK_ID) {
/* task creation failed */
printf("Error: Cannot create task\n");
_task_block();
}
created_task = _task_create(0, MUTEXA, 0);
if (created_task == MQX_NULL_TASK_ID) {
/* task creation failed */
printf("Error: Cannot create task\n");
_task_block();
}
created_task = _task_create(0, MUTEXB, 0);
if (created_task == MQX_NULL_TASK_ID) {
/* task creation failed */
printf("Error: Cannot create task\n");
_task_block();
}
created_task = _task_create(0, SEMA, 0);
if (created_task == MQX_NULL_TASK_ID) {
/* task creation failed */
printf("Error: Cannot create task\n");
_task_block();
}
created_task = _task_create(0, SEMB, 0);
if (created_task == MQX_NULL_TASK_ID) {
/* task creation failed */
printf("Error: Cannot create task\n");
_task_block();
}
created_task = _task_create(0, EVENTA, 0);
if (created_task == MQX_NULL_TASK_ID) {
/* task creation failed */
printf("Error: Cannot create task\n");
_task_block();
}
created_task = _task_create(0, EVENTB, 0);
if (created_task == MQX_NULL_TASK_ID) {
/* task creation failed */
printf("Error: Cannot create task\n");
_task_block();
}
#if MQX_KERNEL_LOGGING
/* create log number 0 */
log_result = _klog_create(200, 0);
if (log_result != MQX_OK) {
/* log 0 could not be created */
printf("Error: Cannot create kernel log\n");
_task_block();
} /* endif */
/* define kernel logging */
_klog_control(0xFFFFFFFF, FALSE);
_klog_control(
KLOG_ENABLED |
KLOG_FUNCTIONS_ENABLED |
KLOG_INTERRUPTS_ENABLED |
KLOG_SYSTEM_CLOCK_INT_ENABLED |
KLOG_CONTEXT_ENABLED |
KLOG_TASKING_FUNCTIONS |
KLOG_ERROR_FUNCTIONS |
KLOG_MESSAGE_FUNCTIONS |
KLOG_INTERRUPT_FUNCTIONS |
KLOG_MEMORY_FUNCTIONS |
KLOG_TIME_FUNCTIONS |
KLOG_EVENT_FUNCTIONS |
KLOG_NAME_FUNCTIONS |
KLOG_MUTEX_FUNCTIONS |
KLOG_SEMAPHORE_FUNCTIONS |
KLOG_WATCHDOG_FUNCTIONS,
TRUE
);
#endif
/*
** LOOP -
*/
while ( TRUE ) {
msg_ptr = _msg_alloc((_pool_id) MsgPool_pool_id );
if (msg_ptr == NULL) {
/* No available message buffer */
}
msg_ptr->SIZE = sizeof(MESSAGE_HEADER_STRUCT);
msg_ptr->SOURCE_QID = msg_ptr->TARGET_QID;
msg_ptr->TARGET_QID = Sender_Queue_qid;
_msgq_send(msg_ptr);
/*
* Service the message queue - Main_Queue
*/
msg_ptr = _msgq_receive_ticks(Main_Queue_qid, NO_TIMEOUT);
/* process message End_msg */
_msg_free(msg_ptr);
} /* endwhile */
} /*end of task*/
/*!
* \brief Creates a new log.
*
* Each entry in the log contains application-specified data, a timestamp (in
* absolute time), and a sequence number.
*
* \param[in] log_number Log number to create (0 through 15).
* \param[in] max_size Maximum size of the data to be stored in _mqx_uints
* (includes LOG_ENTRY_STRUCT headers).
* \param[in] flags One of the following:
* \li LOG_OVERWRITE (When the log is full, write new entries over oldest ones.)
* \li 0 (When the log is full, do not write entries.)
*
* \return MQX_OK
* \return LOG_INVALID (Log_number exceeds 15)
* \return MQX_INVALID_COMPONENT_BASE (Component is not valid.)
* \return MQX_OUT_OF_MEMORY (MQX is out of memory.)
* \return LOG_EXISTS (Log log_number has already been created.)
*
* \warning Creates the log component if it was not created.
*
* \see _log_create_component
* \see _log_destroy
* \see _log_read
* \see _log_write
* \see LOG_ENTRY_STRUCT
*/
_mqx_uint _log_create
(
_mqx_uint log_number,
_mqx_uint max_size,
uint_32 flags
)
{ /* Body */
KERNEL_DATA_STRUCT_PTR kernel_data;
LOG_COMPONENT_STRUCT_PTR log_component_ptr;
LOG_HEADER_STRUCT_PTR log_header_ptr;
_mqx_uint result;
_GET_KERNEL_DATA(kernel_data);
#if MQX_CHECK_ERRORS
if (log_number >= LOG_MAXIMUM_NUMBER)
{
return(LOG_INVALID);
} /* Endif */
#endif
log_component_ptr = (LOG_COMPONENT_STRUCT_PTR)
kernel_data->KERNEL_COMPONENTS[KERNEL_LOG];
if (log_component_ptr == NULL)
{
result = _log_create_component();
log_component_ptr = (LOG_COMPONENT_STRUCT_PTR)
kernel_data->KERNEL_COMPONENTS[KERNEL_LOG];
#if MQX_CHECK_MEMORY_ALLOCATION_ERRORS
if (log_component_ptr == NULL)
{
return(result);
} /* Endif */
#endif
} /* Endif */
#if MQX_CHECK_VALIDITY
if (log_component_ptr->VALID != LOG_VALID)
{
return(MQX_INVALID_COMPONENT_BASE);
} /* Endif */
#endif
log_header_ptr = (LOG_HEADER_STRUCT_PTR)
_mem_alloc_system((_mem_size)(sizeof(LOG_HEADER_STRUCT) + max_size *
sizeof(_mqx_uint)));
#if MQX_CHECK_MEMORY_ALLOCATION_ERRORS
if (log_header_ptr == NULL)
{
return(MQX_OUT_OF_MEMORY);
} /* Endif */
#endif
_mem_set_type(log_header_ptr, MEM_TYPE_LOG);
log_header_ptr->FLAGS = flags;
log_header_ptr->FLAGS |= LOG_ENABLED;
log_header_ptr->NUMBER = 1;
log_header_ptr->MAX = max_size;
log_header_ptr->SIZE = 0;
log_header_ptr->LOG_WRITE = &log_header_ptr->DATA[0];
log_header_ptr->LOG_READ = log_header_ptr->LOG_WRITE;
log_header_ptr->LAST_LOG = log_header_ptr->LOG_WRITE;
log_header_ptr->LOG_START = log_header_ptr->LOG_WRITE;
log_header_ptr->LOG_END = &log_header_ptr->DATA[max_size];
log_header_ptr->LOG_NEXT = NULL;
_int_disable();
#if MQX_CHECK_ERRORS
if (log_component_ptr->LOGS[log_number] != NULL)
{
_int_enable();
_mem_free(log_header_ptr);
return(LOG_EXISTS);
} /* Endif */
#endif
log_component_ptr->LOGS[log_number] = log_header_ptr;
_int_enable();
return(MQX_OK);
} /* Endbody */
void Main_task(uint_32 initial_data)
{
#if MQX_USE_LOGS || MQX_KERNEL_LOGGING
_mqx_uint log_result;
#endif
#if MQX_USE_LOGS
/* create the log component */
log_result = _log_create_component();
if (log_result != MQX_OK) {
printf("Error: log component could not be created\n");
} /* endif */
#endif
#if MQX_KERNEL_LOGGING == 1
/* create log number 0 */
log_result = _klog_create(9000, LOG_OVERWRITE);
if (log_result != MQX_OK) {
printf("Error: log 0 could not be created\n");
} /* endif */
/* define kernel logging */
_klog_control(0xFFFFFFFF, FALSE);
_klog_control(
KLOG_ENABLED |
//KLOG_FUNCTIONS_ENABLED |
//KLOG_INTERRUPTS_ENABLED |
//KLOG_SYSTEM_CLOCK_INT_ENABLED |
KLOG_CONTEXT_ENABLED |
//KLOG_TASKING_FUNCTIONS |
//KLOG_ERROR_FUNCTIONS |
// KLOG_MESSAGE_FUNCTIONS |
//KLOG_INTERRUPT_FUNCTIONS |
//KLOG_MEMORY_FUNCTIONS |
//KLOG_TIME_FUNCTIONS |
//KLOG_EVENT_FUNCTIONS |
//KLOG_NAME_FUNCTIONS |
//KLOG_MUTEX_FUNCTIONS |
//KLOG_SEMAPHORE_FUNCTIONS |
KLOG_WATCHDOG_FUNCTIONS,
TRUE
);
#endif
/*******************************
*
* START YOUR CODING HERE
*
********************************/
for (;;)
{
/* Run the shell */
Shell(Shell_commands, NULL);
printf("Shell exited, restarting...\n");
}
}
