/*FUNCTION**********************************************************************
*
* Function Name : OSA_MsgQCreate
* Description : This function is used to create a message queue.
* Return the handle to the message queue if create successfully, otherwise
* return 0.
*
*END**************************************************************************/
msg_queue_handler_t OSA_MsgQCreate(msg_queue_t *queue,
uint16_t message_number,
uint16_t message_size)
{
INT8U err;
queue->pQueue = OSQCreate(queue->msgTbl, message_number);
if (!queue->pQueue)
{
return (msg_queue_handler_t)0;
}
/* Use OS_MEM to manage the memory which is used to save messages*/
queue->pMem = OSMemCreate(queue->msgs,
message_number,
message_size*sizeof(int32_t),
&err);
if (!queue->pMem)
{
OSQDel(queue->pQueue, OS_DEL_ALWAYS, &err);
return (msg_queue_handler_t)0;
}
queue->size = message_size;
return (msg_queue_handler_t)queue;
}
/*FUNCTION**********************************************************************
*
* Function Name : OSA_MsgQCreate
* Description : This function is used to create a message queue.
* Return the handle to the message queue if create successfully, otherwise
* return 0.
*
*END**************************************************************************/
msg_queue_handler_t OSA_MsgQCreate(msg_queue_t *queue,
uint16_t message_number,
uint16_t message_size)
{
OS_ERR err;
OSQCreate(&(queue->queue), "queue", message_number, &err);
if (OS_ERR_NONE != err)
{
return (msg_queue_handler_t)0;
}
/* Use OS_MEM to manage the memory which is used to save messages */
OSMemCreate(&(queue->mem),
"queue_mem",
queue->msgs,
message_number,
message_size*sizeof(int32_t),
&err);
if (OS_ERR_NONE != err)
{
OSQDel(&(queue->queue), OS_OPT_DEL_ALWAYS, &err);
return (msg_queue_handler_t)0;
}
queue->size = message_size;
return (msg_queue_handler_t)queue;
}
/*********************************************************************************************************
** Function name: zyMsgCreate
** Descriptions: 创建消息通道
** input parameters: ulMsgs: 可以缓存消息数目
** ulMsgSize: 消息大小
** output parameters: none
** Returned value: 消息通道标识
** 0: 不成功
** Created by: Chenmingji
** Created Date: 2009-07-23
**--------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date:
*********************************************************************************************************/
unsigned long zyMsgCreate (INT32S ulMsgs, INT32U ulMsgSize)
{
INT32U ulSize; /* 需要的内存空间 */
INT8U ucErr; /* 错误代码 */
__ZY_IF_MSG *pimTmp1;
INT8U *pucTmp2;
/*
* 参数校验
*/
if (ulMsgs == 0) {
return 0;
}
if (ulMsgSize == 0) {
return 0;
}
/*
* 分配存储空间
*/
ulSize = sizeof(__ZY_IF_MSG) + ulMsgs * sizeof(void *) + ulMsgs * ulMsgSize;
pucTmp2 = (INT8U *)zyHeapMalloc(ulSize);
if (pucTmp2 == NULL) {
return 0;
}
pimTmp1 = (__ZY_IF_MSG *)pucTmp2;
/*
* 创建消息队列
*/
pimTmp1->poeQ = OSQCreate((void **)(pucTmp2 + sizeof(__ZY_IF_MSG)), (INT16U)ulMsgs);
if (pimTmp1->poeQ == NULL) {
zyHeapFree(pucTmp2);
return 0;
}
/*
* 创建内存管理单元
*/
pimTmp1->pomMsg = OSMemCreate((void *)(pucTmp2 + sizeof(__ZY_IF_MSG) * ulMsgs),
(INT16U)ulMsgs,
ulMsgSize,
&ucErr
);
if (pimTmp1->pomMsg == NULL) {
OSQDel(pimTmp1->poeQ, OS_DEL_ALWAYS, &ucErr);
zyHeapFree(pucTmp2);
return 0;
}
pimTmp1->ulMsgSize = ulMsgSize;
return (unsigned long)pimTmp1;
}
void OSPrintfInit(void)
{
INT8U err;
pUartMem=OSMemCreate(UartBuf,UartMsgNum,UartMsgBufLengh,&err);//Create a mem for Uart post Msg
pUart_Q=OSQCreate(&MsgUart[0],UartMsgNum);//Create a Quen for Uart
OSTaskCreate(TaskUart,(void*)0,&TaskUartStk[TaskUartStkLengh-1],TaskUartPrio);//Creat a Task to sent Msg to Uart
}
static void uartTask(void* unused) {
dn_error_t dnErr;
INT8U osErr;
dn_uart_open_args_t uartOpenArgs;
INT32U rxLen;
INT32U channelMsgType;
INT32S err;
// create the memory block for the UART channel
bridge_app_v.uartRxChannelMem = OSMemCreate(
bridge_app_v.uartRxChannelMemBuf,
1,
sizeof(bridge_app_v.uartRxChannelMemBuf),
&osErr
);
ASSERT(osErr==OS_ERR_NONE);
// create an asynchronous notification channel
dnErr = dn_createAsyncChannel(bridge_app_v.uartRxChannelMem, &bridge_app_v.uartRxChannel);
ASSERT(dnErr==DN_ERR_NONE);
// associate the channel descriptor with UART notifications
dnErr = dn_registerChannel(bridge_app_v.uartRxChannel, DN_MSG_TYPE_UART_NOTIF);
ASSERT(dnErr==DN_ERR_NONE);
// open the UART device
uartOpenArgs.rxChId = bridge_app_v.uartRxChannel;
uartOpenArgs.rate = 115200u;
uartOpenArgs.mode = DN_UART_MODE_M4;
uartOpenArgs.ctsOutVal = 0;
err = dn_open(
DN_UART_DEV_ID,
&uartOpenArgs,
sizeof(uartOpenArgs)
);
ASSERT(err>=0);
while(1) { // this is a task, it executes forever
// wait for UART messages
dnErr = dn_readAsyncMsg(
bridge_app_v.uartRxChannel, // chDesc
bridge_app_v.uartRxBuffer, // msg
&rxLen, // rxLen
&channelMsgType, // msgType
MAX_UART_PACKET_SIZE, // maxLen
0 // timeout (0==never)
);
ASSERT(dnErr==DN_ERR_NONE);
ASSERT(channelMsgType==DN_MSG_TYPE_UART_NOTIF);
// call the callback
serial_rx(bridge_app_v.uartRxBuffer,rxLen);
}
}
void USART1_Init(unsigned long baud)
{
u8 MemTestErr;
USART1RecvPtrW = 0;
USART1RecvPtrR = 0;
USART1SendQBoxHost = 0;
USART1SendQBoxTail = 0;
USART1SendQFree = USART1_SEND_MAX_BOX;
USART1_Configuration(baud);
OSQUSART1Index=(OSMEMTcb *)OSMemCreate(OSUSART1MemQ,OS_MEM_USART1_BLK,OS_MEM_USART1_MAX/OS_MEM_USART1_BLK, &MemTestErr);
}
// Initialize sys arch
void _sys_init(void)
{
u8_t ucErr;
// init mem used by sys_mbox_t, use ucosII functions
// 指定内存起始地址以4字节对齐
pQueueMem = OSMemCreate(
(void*)((u32_t)((u32_t)pcQueueMemoryPool+MEM_ALIGNMENT-1) & ~(MEM_ALIGNMENT-1)),
MAX_QUEUES, sizeof(TQ_DESCR), &ucErr
);
LWIP_ASSERT( "OSMemCreate ", ucErr == OS_ERR_NONE );
}
static void AppMemCreate(void)
{
OS_ERR error = OS_ERR_NONE;
void *p_addr;
void *p_addr_end;
OS_MEM_QTY n_blks;
OS_MEM_SIZE blk_size;
p_addr = __section_begin("OS_4K_MEM_POOL");
p_addr_end = __section_end("OS_4K_MEM_POOL");
n_blks = ((OS_MEM_SIZE)p_addr_end - (OS_MEM_SIZE)p_addr)/(4*1024);
blk_size = (4*1024);
OSMemCreate(&AppMem4KB,
"4KB memory for app",
p_addr,
n_blks,
blk_size,
&error );
p_addr = __section_begin("OS_2M_MEM_POOL");
p_addr_end = __section_end("OS_2M_MEM_POOL");
n_blks = ((OS_MEM_SIZE)p_addr_end - (OS_MEM_SIZE)p_addr) / (2*1024*1024);
blk_size = (2*1024*1024);
OSMemCreate(&AppMem2MB,
"2MB memory for app",
p_addr,
n_blks,
blk_size,
&error );
}
static void lptimerTask(void* unused) {
dn_error_t dnErr;
INT8U osErr;
INT32U msg;
INT32U rxLen;
INT32U msgType;
// give time for stack banner to print
OSTimeDly(1 * SECOND);
// create the memory block for the UART channel
lptimer_app_v.eventChIdMem = OSMemCreate( lptimer_app_v.eventChIdMemBuf,
EVENT_CHANNEL_SIZE, EVENT_CHANNEL_MSG_SIZE, &osErr);
ASSERT(osErr==OS_ERR_NONE);
// create an asynchronous notification channel
dnErr = dn_createAsyncChannel(lptimer_app_v.eventChIdMem, &lptimer_app_v.eventChId);
ASSERT(dnErr==DN_ERR_NONE);
// associate the channel descriptor with UART notifications
dnErr = dn_registerChannel(lptimer_app_v.eventChId, DN_MSG_TYPE_LPTIMER_NOTIF);
ASSERT(dnErr==DN_ERR_NONE);
while(1) { // this is a task, it executes forever
// wait for event message
dnErr = dn_readAsyncMsg(lptimer_app_v.eventChId, &msg, &rxLen, &msgType, sizeof(msg), 0 );
ASSERT(dnErr==DN_ERR_NONE);
ASSERT(msgType==DN_MSG_TYPE_LPTIMER_NOTIF);
if(msg & DN_LPTIMER_COMPARE_EVENT) {
// print message received - the count will have increased slightly since the capture
dnm_ucli_printf("COMP Event %d\r\n", msg);
}
if(msg & DN_LPTIMER_CAPTURE_EVENT) {
// print message received
dnm_ucli_printf("CAPT Event %d\r\n", msg);
}
if(msg & DN_LPTIMER_OVERFLOW_EVENT) {
lptimer_app_v.overflow++;
}
}
}
/* Initialize sys arch */
void
sys_init(void)
{
u8_t i, ucErr;
/* init mem used by sys_mbox_t, use ucosII functions */
/* 指定内存起始地址以4字节对齐 */
pQueueMem = OSMemCreate( (void*)((u32_t)((u32_t)pcQueueMemoryPool+MEM_ALIGNMENT-1) & ~(MEM_ALIGNMENT-1)),
MAX_QUEUES, sizeof(TQ_DESCR), &ucErr );
LWIP_ASSERT( "OSMemCreate ", ucErr == OS_ERR_NONE );
/* Initialize the the per-thread sys_timeouts structures */
/* make sure there are no valid pids in the list */
for(i = 0; i < LWIP_TASK_MAX; i++)
{
lwip_timeouts[i].next = NULL;
}
}
void OS_CPU_FP_Init (void)
{
INT8U err;
#if OS_TASK_STAT_EN && OS_TASK_CREATE_EXT_EN
OS_TCB *ptcb;
void *pblk;
#endif
OSFPPartPtr = OSMemCreate(&OSFPPart[0][0], OS_NTASKS_FP, OS_FP_STORAGE_SIZE, &err);
#if OS_TASK_STAT_EN && OS_TASK_CREATE_EXT_EN /* CHANGE 'OPTIONS' for OS_TaskStat() */
ptcb = OSTCBPrioTbl[OS_TASK_STAT_PRIO];
ptcb->OSTCBOpt |= OS_TASK_OPT_SAVE_FP; /* Allow floating-point support for Statistic task */
pblk = OSMemGet(OSFPPartPtr, &err); /* Get storage for VFP registers */
if (pblk != (void *)0) { /* Did we get a memory block? */
ptcb->OSTCBExtPtr = pblk; /* Yes, Link to task's TCB */
OS_CPU_FP_Save(pblk); /* Save the VFP registers in block */
}
#endif
}
static void uartRxTask(void* unused) {
dn_error_t dnErr;
INT8U osErr;
dn_uart_open_args_t uartOpenArgs;
INT32U rxLen;
INT32U msgType;
INT8U i;
INT32S err;
// create the memory block for the UART channel
uart_app_v.uartRxChannelMem = OSMemCreate(
uart_app_v.uartRxChannelMemBuf,
1,
sizeof(uart_app_v.uartRxChannelMemBuf),
&osErr
);
ASSERT(osErr==OS_ERR_NONE);
// create an asynchronous notification channel
dnErr = dn_createAsyncChannel(uart_app_v.uartRxChannelMem, &uart_app_v.uartRxChannel);
ASSERT(dnErr==DN_ERR_NONE);
// associate the channel descriptor with UART notifications
dnErr = dn_registerChannel(uart_app_v.uartRxChannel, DN_MSG_TYPE_UART_NOTIF);
ASSERT(dnErr==DN_ERR_NONE);
// open the UART device
uartOpenArgs.rxChId = uart_app_v.uartRxChannel;
uartOpenArgs.eventChId = 0;
uartOpenArgs.rate = 115200u;
uartOpenArgs.mode = DN_UART_MODE_M4;
uartOpenArgs.ctsOutVal = 0;
uartOpenArgs.fNoSleep = 0;
err = dn_open(
DN_UART_DEV_ID,
&uartOpenArgs,
sizeof(uartOpenArgs)
);
ASSERT(err>=0);
while(1) { // this is a task, it executes forever
// wait for UART messages
dnErr = dn_readAsyncMsg(
uart_app_v.uartRxChannel, // chDesc
uart_app_v.uartRxBuffer, // msg
&rxLen, // rxLen
&msgType, // msgType
MAX_UART_PACKET_SIZE, // maxLen
0 // timeout (0==never)
);
ASSERT(dnErr==DN_ERR_NONE);
ASSERT(msgType==DN_MSG_TYPE_UART_NOTIF);
// print message received
dnm_ucli_printf("uart RX (%d bytes)",rxLen);
for (i=0;i<rxLen;i++) {
dnm_ucli_printf(" %02x",uart_app_v.uartRxBuffer[i]);
}
dnm_ucli_printf("\r\n");
}
}
void cli_task_init(dnm_cli_cont_t* cliContext, char* appName, dnm_cli_cmdDef_t* cliCmds) {
dn_error_t dnErr;
INT8U osErr;
OS_MEM* cliChannelMem;
// store params
cli_task_v.cliContext = cliContext;
cli_task_v.appName = appName;
cli_task_v.cliCmds = cliCmds;
// open CLI port
dnErr = dnm_cli_openPort(DN_CLI_PORT_C0, 9600);
ASSERT(dnErr==DN_ERR_NONE);
// change CLI access level
dnErr = dnm_cli_changeAccessLevel(DN_CLI_ACCESS_USER);
ASSERT(dnErr==DN_ERR_NONE);
// print appName
dnm_cli_printf("%s app, ver %d.%d.%d.%d\n\r", cli_task_v.appName,
VER_MAJOR,
VER_MINOR,
VER_PATCH,
VER_BUILD);
// stop here is no CLI commands to register
if (cli_task_v.cliCmds==NULL) {
return;
}
// create a memory block for CLI notification channel
cliChannelMem = OSMemCreate(
cli_task_v.cliChannelBuffer,
1,
DN_CH_ASYNC_RXBUF_SIZE(DN_CLI_NOTIF_SIZE),
&osErr
);
ASSERT(osErr==OS_ERR_NONE);
// create the CLI notification channel
dnErr = dn_createAsyncChannel(
cliChannelMem,
&cli_task_v.cliChannelDesc
);
ASSERT(dnErr==DN_ERR_NONE);
// register the channel for CLI input messages
dnErr = dn_registerChannel(
cli_task_v.cliChannelDesc,
DN_MSG_TYPE_CLI_NOTIF
);
ASSERT(dnErr==DN_ERR_NONE);
// create the CLI task
osErr = OSTaskCreateExt(
cliTask,
NULL,
(OS_STK*)&cli_task_v.cliTaskStack[CLI_TASK_STK_SIZE-1],
CLI_TASK_PRIORITY,
CLI_TASK_PRIORITY,
(OS_STK*)cli_task_v.cliTaskStack,
CLI_TASK_STK_SIZE,
NULL,
OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR
);
ASSERT(osErr==OS_ERR_NONE);
OSTaskNameSet(CLI_TASK_PRIORITY, CLI_TASK_NAME, &osErr);
ASSERT(osErr==OS_ERR_NONE);
}
int gd_system_init()
{
INT8U err;
memset(&gd_system, 0, sizeof(gd_system_t));
/********************** Initialize Uart ********************************************/
// Create guart task sem
gd_system.gm_operate_sem = OSSemCreate(1);
gd_system.gm2sp_buf_sem = OSSemCreate(1);
gd_system.sp2gm_mem_sem = OSSemCreate(1);
/********************** Create Memory Partitions *******************************/
gd_system.gd_msg_PartitionPtr = OSMemCreate(gd_msg_partition, GD_MSG_COUNT, GD_MSG_SIZE, &err);
gd_system.sp2gm_buf_PartitionPtr = OSMemCreate(sp2gm_buf_partition, SP2GM_FRAME_NODE_COUNT, GD_FRAME_NODE_SIZE, &err);
//gd_system.gm2sp_buf_PartitionPtr = OSMemCreate(gm2sp_buf_partition, GM2SP_FRAME_NODE_COUNT, GD_FRAME_NODE_SIZE, &err);
/********************** Initialize Config Task *********************************/
// TaskId
gd_system.config_task.task_id = user_tasks[GD_TASK_CONFIG_ID].pid;
// Priority
gd_system.config_task.prio= user_tasks[GD_TASK_CONFIG_ID].prio;
/********************** Initialize SUART Task *********************************/
// TaskId
gd_system.suart_task.task_id = user_tasks[GD_TASK_SUART_ID].pid;
// Priority
gd_system.suart_task.prio= user_tasks[GD_TASK_SUART_ID].prio;
// Create suart task queue
gd_system.suart_task.q_suart = OSQCreate(&gd_system.suart_task.QMsgTbl[0], SUART_QMSG_COUNT);
/********************** Initialize GUART Task *********************************/
// TaskId
gd_system.guart_task.task_id = user_tasks[GD_TASK_GUART_ID].pid;
// Priority
gd_system.guart_task.prio= user_tasks[GD_TASK_GUART_ID].prio;
// Create guart task queue
gd_system.guart_task.q_guart = OSQCreate(&gd_system.guart_task.QMsgTbl[0], GUART_QMSG_COUNT);
/********************** Initialize Network Task *********************************/
// TaskId
gd_system.network_task.task_id = user_tasks[GD_TASK_NETWORK_ID].pid;
// Priority
gd_system.network_task.prio= user_tasks[GD_TASK_NETWORK_ID].prio;
// Create network task queue
gd_system.network_task.q_network = OSQCreate(&gd_system.network_task.QMsgTbl[0], NETWORK_QMSG_COUNT);
// Link info
return 0;
}
//---------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
void Task_START(void *pdata)
{
INT8U err;
OpenTimer0(TIMER_INT_ON & T0_16BIT & T0_SOURCE_INT & T0_PS_1_1);
OpenUSART( USART_TX_INT_OFF &
USART_RX_INT_OFF &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
//USART_BRGH_LOW,
USART_BRGH_HIGH,
51 );//12 - 9600 LOW
//8 - 57.6k HIGH
OpenADC( ADC_FOSC_32 &
ADC_RIGHT_JUST &
ADC_12_TAD,
ADC_CH0 & ADC_VREFPLUS_VDD & ADC_VREFMINUS_VSS &
ADC_INT_OFF, 15 );
TRISA |= 0b01111111;
TRISD &= 0b01111111;
TRISE |= 0b00000111;
ADCON1 &= 0b00000000;
ADCON1 |= 0b00000000;
CVRCON &= 0b00111111;
/*
ANSEL = 0; //turn off all other analog inputs
ANSELH = 0;
ANSELbits.ANS0 = 1; // turn on RA0 analog
ADCON1 = 0;
ADCON2 = 0b00111000;
ADCON0 = 0b00000001;
*/
//STask1 = OSSemCreate(1);
STaskTxSerial = OSSemCreate(0);
STeclado = OSSemCreate(1);
dMemory = OSMemCreate((void *)dMemoryData,MEMORY_BLOCK_NUM,MEMORY_SIZE,&err);
QueueADC0 = OSQCreate((void *)QueueADC0Message,QSize);
OSTaskCreate(TaskSensores, (void *)0, &TaskSensoresStk[0], 1);
OSTaskCreate(TaskTxSerial, (void *)0, &TaskTxSerialStk[0], 5);
OSTaskCreate(TaskTeclado, (void *)0, &TaskTecladoStk[0], 10);
//i_data = *((int *)pdata);
// task loop
for(;;)
{
salidaLED_0 = !(salidaLED_0);
OSTimeDly(50);
salidaLED_0 = !(salidaLED_0);
OSTimeDly(50);
}
}
