void BSP_Init (void)
{
// Interrupt initialization
BSP_IntInit();
// Initailize system services, clocks, etc.
BSP_SysInit();
// RGB LED initialization
BSP_LED_Init();
// Push Button initialization
BSP_SWITCH_Init();
// PIR sensor initialization
BSP_PIR_Init();
// UART initialization
BSP_UART_Init();
// Semaphore Create
sharedDataSem = OSSemCreate(1);
// semaphore Create
sharedDataSemUart = OSSemCreate(1);
// Mailbox Create
MailBox1 = OSMboxCreate(&global_pir_val);
}
/*
*********************************************************************************************************
* MAIN
*********************************************************************************************************
*/
int main (void)
{
OSInit(); /* Initialize uC/OS-II */
OSTaskCreateExt(Task_Start,
(void *)0,
&TASK_START_STK[127],
TASK_START_PRIO,
TASK_START_ID,
&TASK_START_STK[0],
300,
(void *)0,//&TaskUserData[TASK_4_ID]
0);
RecPackedFlag= OSSemCreate(0);
RecBufOverFlowFlag= OSSemCreate(0);
RecTcpPackedFlag= OSSemCreate(0);
RecPingPackedFlag= OSSemCreate(0);
SendFlag= OSSemCreate(1);
RecIcmpQFlag= OSQCreate(&RecIcmpQ[0],Q_Max_Size);
RecTcpQFlag= OSQCreate(&RecTcpQ[0],Q_Max_Size);
RecUdpQFlag= OSQCreate(&RecUdpQ[0],Q_Max_Size);
OSStart(); /* Start multitasking */
}
void Task_START(void *p_arg)
{
(void)p_arg; //'p_arg'没有用到，防止编译器警告
adc_MBOX = OSMboxCreate((void *)0);
key_SEM = OSSemCreate(0);
keyDis_SEM = OSSemCreate(0);
A8_SEM = OSSemCreate(0);
OSTaskCreate(Task_LED,(void *)0,
&led_task_stk[LED_TASK_STK_SIZE-1],LED_TASK_PRIO);
OSTaskCreate(Task_USART1,(void *)0,
&usart1_task_stk[USART1_TASK_STK_SIZE-1],USART1_TASK_PRIO);
OSTaskCreate(Task_LEDDIS,(void *)0,
&ledDis_task_stk[LEDDIS_TASK_STK_SIZE-1],LEDDIS_TASK_PRIO);
OSTaskCreate(Task_ADC1,(void *)0,
&adc1_task_stk[ADC1_TASK_STK_SIZE-1],ADC1_TASK_PRIO);
OSTaskCreate(Task_EXTI,(void *)0,
&exti_task_stk[EXTI_TASK_STK_SIZE-1],EXTI_TASK_PRIO);
OSTaskCreate(Task_CALCULATE,(void *)0,
&calculate_task_stk[CALCULATE_TASK_STK_SIZE-1],CALCULATE_TASK_PRIO);
OSTaskCreate(Task_A8CONNECT,(void *)0,
&A8connect_task_stk[A8CONNECT_TASK_STK_SIZE-1],A8CONNECT_TASK_PRIO);
while(1)
{
OSTimeDlyHMSM(0,0,0,10);
}
}
/*
*********************************************************************************************************
* App_EventCreate
*
* Description : Creates the application events.
*
* Argument(s) : none.
*
* Return(s) : none.
*
* Caller(s) : App_TaskStart().
*
* Note(s) : none.
*********************************************************************************************************
*/
static void App_EventCreate (void)
{
g_key_para.sem = OSSemCreate(0);
g_sem_end = OSSemCreate(0);
g_sem_pc = OSSemCreate(0);
g_sem_mems = OSSemCreate(0);
}
/*
*********************************************************************************************************
* AnalogCaptureTask TASK
*
*********************************************************************************************************
*/
void AnalogCaptureTask (void *p_arg)
{
(void)p_arg; /* Prevent compiler warning */
OS_ERR err = 0;
CPU_INT32U uCount = 0;
static ADC_CONTROL_BLOCK_t strAdcControlBlock;
InitAdcControlBlock(&strAdcControlBlock); /* Initialize ADC control structures */
InitADCPort(); /* Initialize the ADC */
OSSemCreate(&semAdcIntSignal,"ADC EOC Int signal",0,&err);
OSSemCreate(&semADC_Complete,"ADC completed semaphore",0,&err);
OSMutexCreate(&mutADC,"ADC value",&err);
OSMutexCreate(&mutTMR3,"PWM in",&err);
while (TRUE) {
OSTimeDlyHMSM(0, 0, 0, 50, /* Performs conversions every 100 ms. */
OS_OPT_TIME_HMSM_STRICT,
&err);
ADC1->CR2 |= 1<<21; /* Trigger the conversion */
OSSemPend(&semAdcIntSignal, /* Wait for the end of conversion */
0, /* (This semaphore is posted by the ADC1_ISR) */
OS_OPT_PEND_BLOCKING,
(CPU_TS*)NULL,&err);
ReportAdcSample(ADC_CHANNEL_1, &strAdcControlBlock);
if (++uCount > 5)
{
BSP_LED_Toggle(2); /* Toggle the BSP Led #3 */
uCount = 0;
}
}
}
void OSTmr_Init( void )
{
#if OS_EVENT_NAME_SIZE > 10
INT8U err;
#endif
INT16U i;
OS_TMR *ptmr1;
OS_TMR *ptmr2;
OS_MemClr( ( INT8U * ) & OSTmrTbl[0], sizeof( OSTmrTbl ) ); /* Clear all the TMRs */
OS_MemClr( ( INT8U * ) & OSTmrWheelTbl[0], sizeof( OSTmrWheelTbl ) ); /* Clear the timer wheel */
ptmr1 = &OSTmrTbl[0];
ptmr2 = &OSTmrTbl[1];
for ( i = 0; i < ( OS_TMR_CFG_MAX - 1 ); i++ )
{ /* Init. list of free TMRs */
ptmr1->OSTmrType = OS_TMR_TYPE;
ptmr1->OSTmrState = OS_TMR_STATE_UNUSED; /* Indicate that timer is inactive */
ptmr1->OSTmrNext = ( void * ) ptmr2; /* Link to next timer */
#if OS_TMR_CFG_NAME_SIZE > 1
ptmr1->OSTmrName[0] = '?'; /* Unknown name */
ptmr1->OSTmrName[1] = OS_ASCII_NUL;
#endif
ptmr1++;
ptmr2++;
}
ptmr1->OSTmrType = OS_TMR_TYPE;
ptmr1->OSTmrState = OS_TMR_STATE_UNUSED; /* Indicate that timer is inactive */
ptmr1->OSTmrNext = ( void * ) 0; /* Last OS_TMR */
#if OS_TMR_CFG_NAME_SIZE > 1
ptmr1->OSTmrName[0] = '?'; /* Unknown name */
ptmr1->OSTmrName[1] = OS_ASCII_NUL;
#endif
OSTmrTime = 0;
OSTmrUsed = 0;
OSTmrFree = OS_TMR_CFG_MAX;
OSTmrFreeList = &OSTmrTbl[0];
OSTmrSem = OSSemCreate( 1 );
OSTmrSemSignal = OSSemCreate( 0 );
#if OS_EVENT_NAME_SIZE > 18
OSEventNameSet( OSTmrSem, ( INT8U * ) "uC/OS-II TmrLock", &err ); /* Assign names to semaphores */
#else
#if OS_EVENT_NAME_SIZE > 10
OSEventNameSet( OSTmrSem, ( INT8U * ) "OS-TmrLock", &err );
#endif
#endif
#if OS_EVENT_NAME_SIZE > 18
OSEventNameSet( OSTmrSemSignal, ( INT8U * ) "uC/OS-II TmrSignal", &err );
#else
#if OS_EVENT_NAME_SIZE > 10
OSEventNameSet( OSTmrSemSignal, ( INT8U * ) "OS-TmrSig", &err );
#endif
#endif
OSTmr_InitTask( );
}
void USART_File_Init()
{
file_usart1.semaphore = OSSemCreate(0);
file_usart2.semaphore = OSSemCreate(0);
file_usart3.semaphore = OSSemCreate(0);
#ifdef STM32F10X_CL
file_uart4.semaphore = OSSemCreate(0);
file_uart5.semaphore = OSSemCreate(0);
#endif
}
void alt_iniche_init(void)
{
extern OS_EVENT * mheap_sem_ptr;
extern void *net_task_sem_ptr;
/* initialize the npalloc() heap semaphore */
mheap_sem_ptr = OSSemCreate(1);
if (!mheap_sem_ptr)
panic("mheap_sem_ptr create err");
/* get the uCOS semaphore used for LOCK_NET_RESOURCE(NET_RESID) */
net_task_sem_ptr = (void*)OSSemCreate(1);
if (!net_task_sem_ptr)
panic("net_task_sem_ptr create err");
rcvdq_sem_ptr = OSSemCreate(0);
if (!rcvdq_sem_ptr)
panic("rcvdq_sem_ptr create err");
#ifdef OS_PREEMPTIVE
ping_sem_ptr = OSSemCreate(0); /* PING app */
if (!ping_sem_ptr)
panic("ping_sem_ptr create err");
ftpc_sem_ptr = OSSemCreate(0); /* FTP Client app */
if (!ftpc_sem_ptr)
panic("ftpc_sem_ptr create err");
#endif /* OS_PREEMPTIVE */
#ifndef TCPWAKE_RTOS
/*
* clear global_TCPwakeup_set
*/
{
int i;
for (i = 0; i < GLOBWAKE_SZ; i++)
{
global_TCPwakeup_set[i].ctick = 0;
}
global_TCPwakeup_setIndx = 0;
}
{
INT8U mute_err;
global_wakeup_Mutex = OSMutexCreate(WAKEUP_MUTEX_PRIO, &mute_err);
if (mute_err != OS_NO_ERR)
{
dprintf("*** uCOS init, can't create global_wakeup_Mutex = %d\n", mute_err);
dtrap();
}
}
#endif /* TCPWAKE_RTOS */
}
/* Init OS */
void GUI_X_InitOS(void)
{
/* Create Mutex lock */
g_gui_mutx = OSSemCreate (1);
//configASSERT (xQueueMutex != NULL);
/* Queue Semaphore */
g_gui_sem = OSSemCreate (0);
//vSemaphoreCreateBinary( xSemaTxDone );
//configASSERT ( xSemaTxDone != NULL );
}
/// -----------------------------------------------------------------------------------------------------
/// @brief 491 communication initialization function.
/// must be called before calling any other of the user accessible functions.
/// 模块初始化
/// @param None
/// @retval : None
/// -----------------------------------------------------------------------------------------------------
void C491_Init (void)
{
C491_R_N = 0; /// 缓冲区数据初始化
C491_R_BufInIx = 0;
C491_R_BufOutIx = 0;
C491_R_SemPtr = OSSemCreate(0); /// 初始化接收使用的信号量
C491_T_N = 0; /// 缓冲区数据初始化
C491_T_BufOutIx = 0;
C491_T_SemPtr = OSSemCreate(1); /// 初始化发送使用的信号量
BSP_491_Init(); /// 初始化IO及中断
}
int main (void)
{
OS_ERR err;
#if (CPU_CFG_NAME_EN == DEF_ENABLED)
CPU_ERR cpu_err;
#endif
hardware_init();
GPIO_DRV_Init(switchPins, ledPins);
#if (CPU_CFG_NAME_EN == DEF_ENABLED)
CPU_NameSet((CPU_CHAR *)"MK64FN1M0VMD12",
(CPU_ERR *)&cpu_err);
#endif
OSA_Init(); /* Init uC/OS-III. */
OSSemCreate(&MySem1, /* Create Semaphore 1 */
"sem 1",
0,
&err);
OSSemCreate(&MySem2, /* Create Semaphore 2 */
"sem 2",
0,
&err);
INT_SYS_InstallHandler(PORTC_IRQn, SW1_Intr_Handler); // associate ISR with sw1 intr source
INT_SYS_InstallHandler(PORTA_IRQn, SW2_Intr_Handler); // associate ISR with sw2 intr source
OSTaskCreate(&AppTaskStartTCB, /* Create the start task */
"App Task Start",
AppTaskStart,
0u,
APP_CFG_TASK_START_PRIO,
&AppTaskStartStk[0u],
(APP_CFG_TASK_START_STK_SIZE / 10u),
APP_CFG_TASK_START_STK_SIZE,
0u,
0u,
0u,
(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR | OS_OPT_TASK_SAVE_FP),
&err);
OSA_Start(); /* Start multitasking (i.e. give control to uC/OS-III). */
while (DEF_ON) { /* Should Never Get Here */
;
}
}
int main (void)
{
AvrInit(); /* Initialize the AVR UART and Timer */
OSInit();
RandomSem = OSSemCreate(1); /* Random number semaphore */
DispStrSem = OSSemCreate(1); /* Display string semaphore */
UartTxSem = OSSemCreate(254); /* Initialize Uart transmit buffer semaphore to 2 */
OSTaskCreate(TaskStart, (void *)0, (void *)&TaskStartStk[TASK_STK_SIZE - 1], 0);
RndNext = 1; /* set random generator seed to 1 */
OSStart(); /* Start multitasking */
return 0;
}
static INT32S InitEvent(void)
{
INT32S re = 0;
g_EventStatic = OSSemCreate(0);
g_EventDynamic = OSSemCreate(0);
//g_EventTran = OSQCreate(g_pTranEventArray, _MAX_TRAN_EVENT);
g_EventRTData = OSSemCreate(0);
//OSSemCreate(&g_EventStatic, (CPU_CHAR *)"g_EventStatic", 0, &err);
//OSSemCreate(&g_EventDynamic, (CPU_CHAR *)"g_EventDynamic", 0, &err);
//OSQCreate(&g_EventTran, (CPU_CHAR *)"g_EventTran", _MAX_TRAN_EVENT, &err);
//OSSemCreate(&g_EventRTData, (CPU_CHAR *)"g_EventRTData", 0, &err);
return re;
}
void Main (void){
INT16U freq;
S3C_SysInit();
OSInit();
LCDInit();
LCDString(0x00," Bitman\n Spartan 117");
delay(10);
for(freq = 10;freq < 300;freq += 10){
S3C_SetPWMBuzzer(freq,freq/2);
delay(1);
}
LCDClear();
delay(8);
LCDString(0," Bitman Lab\n Log System.");
S3C_SetPWMBuzzer(650,10);
S3C_StartPWMBuzzer();
delay(3);
S3C_StopPWMBuzzer();
delay(1);
S3C_StartPWMBuzzer();
delay(3);
S3C_StopPWMBuzzer();
delay(10);
Sem_UART0Tx = OSSemCreate(1);
Sem_UART1Tx = OSSemCreate(1);
Mbox_UART0Rx = OSMboxCreate((void *)0);
Mbox_UART0Tx = OSMboxCreate((void *)0);
Mbox_LEDMAN = OSMboxCreate((void *)0);
Mbox_BEEPMAN = OSMboxCreate((void *)0);
Mbox_LCDMAN = OSMboxCreate((void *)0);
iOPcode = TYPE_DEFAULT;
OSTaskCreate(TaskStart,(void *)0,&Stk_TaskStart[99],10);
OSStart();
}
void OSTmr_Init (void)
{
#if OS_EVENT_NAME_EN > 0u
INT8U err;
#endif
INT16U ix;
INT16U ix_next;
OS_TMR *ptmr1;
OS_TMR *ptmr2;
OS_MemClr((INT8U *)&OSTmrTbl[0], sizeof(OSTmrTbl)); /* Clear all the TMRs */
OS_MemClr((INT8U *)&OSTmrWheelTbl[0], sizeof(OSTmrWheelTbl)); /* Clear the timer wheel */
/* 创建空闲定时器控制块链表 */
for (ix = 0u; ix < (OS_TMR_CFG_MAX - 1u); ix++) { /* Init. list of free TMRs */
ix_next = ix + 1u;
ptmr1 = &OSTmrTbl[ix];
ptmr2 = &OSTmrTbl[ix_next];
ptmr1->OSTmrType = OS_TMR_TYPE;
ptmr1->OSTmrState = OS_TMR_STATE_UNUSED; /* Indicate that timer is inactive */
ptmr1->OSTmrNext = (void *)ptmr2; /* Link to next timer */
#if OS_TMR_CFG_NAME_EN > 0u
ptmr1->OSTmrName = (INT8U *)(void *)"?";
#endif
}
/* 创建链表尾 */
ptmr1 = &OSTmrTbl[ix];
ptmr1->OSTmrType = OS_TMR_TYPE;
ptmr1->OSTmrState = OS_TMR_STATE_UNUSED; /* Indicate that timer is inactive */
ptmr1->OSTmrNext = (void *)0; /* Last OS_TMR */
#if OS_TMR_CFG_NAME_EN > 0u
ptmr1->OSTmrName = (INT8U *)(void *)"?";
#endif
OSTmrTime = 0u;
OSTmrUsed = 0u;
OSTmrFree = OS_TMR_CFG_MAX;
/* 空闲定时器控制块链表头 */
OSTmrFreeList = &OSTmrTbl[0];
OSTmrSem = OSSemCreate(1u);
OSTmrSemSignal = OSSemCreate(0u);
#if OS_EVENT_NAME_EN > 0u /* Assign names to semaphores */
OSEventNameSet(OSTmrSem, (INT8U *)(void *)"uC/OS-II TmrLock", &err);
OSEventNameSet(OSTmrSemSignal, (INT8U *)(void *)"uC/OS-II TmrSignal", &err);
#endif
/* 创建定时器线程 */
OSTmr_InitTask();
}
void GUI_X_InitOS (void)
{
OS_ERR err;
/* 用于资源共享 cnt = 1*/
OSSemCreate((OS_SEM *)&DispSem,
(CPU_CHAR *)"DispSem",
(OS_SEM_CTR )1,
(OS_ERR *)&err);
/* 用于事件触发 cnt = 0*/
OSSemCreate((OS_SEM *)&EventSem,
(CPU_CHAR *)"EventSem",
(OS_SEM_CTR )0,
(OS_ERR *)&err);
}
/**********************************************************
TimeInit - function that initializes timer, mutex, and clock task.
* sets values to timeOfDay if reset button is hit
Creates: ClockTimer, ClockMutexKey, SecFlag
*********************************************************8*/
void TimeInit(void)
{
INT8U err;
TimeOfDay.hr = 0x0C;
TimeOfDay.min = 0x00;
TimeOfDay.sec = 0x00;
ClockTimer = OSTmrCreate(0,
10,
OS_TMR_OPT_PERIODIC,
ClockTimerFnct,
(void *)0,
"Clock Timer ",
&err);
OSTmrStart(ClockTimer, &err);
ClockMutexKey = (CLOCK_PIP, &err);
(void)OSTaskCreate(ClockTask,
(void *)0,
(void *)&ClockTaskStk[CLOCKTASK_STK_SIZE],
CLOCKTASK_PRIO);
SecFlag = OSSemCreate(0);
}
/***************************************************************************************************************************
**函数名称: ip_input
**函数功能:
eth_hdr:
+----------------------------------------------------------------------------------------+
+ desMAC[6] | srcMAC[6] | type[2]( ARP / IP) | 数据[46-1500] | 校验[4] +
+----------------------------------------------------------------------------------------+
*注:
desMAC[6]: 目的MAC地址;
srcMAC[6]: 源MAC地址;
type[2]: 类型(IP:0X800/ARP:0X806)
数据[46-1500]:具体数据;
校验[4]:校验;
etharp_hdr:
+-----------------------------------------------------------------------------------------------------+
+ hwhdr[2] | porotl[2] | hwlen[1] | porotllen[1] | op[2] | srcMAC[6] | srcIP[4] |desMAC[6] | desIP[4] +
+-----------------------------------------------------------------------------------------------------+
*注:
hwhdr[2]:硬件类型字段-表示硬件地址的类型,它的值为1即表示以太网MAC地址,长度为6个字节;
porotl[2]:协议类型字段表示要映射的协议地址类型,它的值为0X800即表示要映射的IP地址;
hwlen[1]: 硬件地址长度,对于以太网ARP请求或者应答来说,他的值为6;
porotllen[1]:协议地址长度,对于以太网ARP请求或者应答来说,他的值为4;
op[2]:操作类型 ARP请求=1,ARP应答=2,RARP请求=3,RARP=4;
srcMAC[6]:发送端MAC地址;
srcIP[4]: 发送端IP地址;
desMAC[6]:目的端MAC地址
desIP[4]: 目的端IP地址;
ip_hdr:
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+ v(bit4) | hdrlen(bit4) | TOS[1] | len[2] | flag0[2] | flag1(bit3) | offset(bit13) | ttl[1] | porotl[1] | hdrchecsum[2] | srcIP[4] | desIP[4] | 选项[...] | data[N] + +
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
*注:
v(bit4): 版本号,目前的版本号是4即IPv4;
hdrlen(bit4): 首部长度-指首部站32Bit字的数目,包括可选项,由于它是个4bit因此首部最长60字节;
TOS[1]:包括一个3bit的优先字段,4bit TOS字段和1 bit未使用但必须为0,如果所有4bit都为0,即一般服务;
len[2]:整个IP数据报的长度以字节为单位;
flag0[2]:指唯一标示主机发送的每一份数据报,通常每发送一份报文值就会加1;
flag1(bit3): 用于在IP数据包分片时使用;
offset(bit13): 用于在IP数据包分片时使用;
ttl[1]:描述该IP数据包最多能被转发多少次,每经过一次转发,该值就会减1,当该值为0时,一个ICMP报文会被返回至源主机;
porotl[1]: 协议字段描述该IP数据包是来自上层哪个协议,改值为1表示为ICMP,2=IGMP,6=TCP,17=UDP;
hdrchecsum[2]:首部校验和只针对IP首部做校验,它并不关心其内部数据在传输过程中出错与否,对于数据校验是上层协议负责的;
srcIP[4]:源IP地址;
desIP[4]:目标IP地址;
选项[...]:选项,可有可无;
data[N]:数据data;
icmp_hdr:
+--------------------------------------------------------------------------------+
+ type[1] | code[1] | checksum[2] | others[N](不同的类型和代码有不同的内容) |
+--------------------------------------------------------------------------------+
**入口参数:
**返回参数:
***************************************************************************************************************************/
void ipcFlyEthernetInit(void)
{
struct ip_addr ip_computer;
memset(&flyEhternetInfo,0,sizeof(flyEhternetInfo));
flyEhternetInfo.LwIPSem = OSSemCreate(0);
if(NULL == flyEhternetInfo.LwIPSem)
{
LIBMCU_DEBUG(ETHERNTE_DEBUG,("\r\n OSSemCreate Fail"));
}
tcpip_init(NULL,NULL);
IP4_ADDR(&flyEhternetInfo.ipaddr, 192, 168, 8, 7);
IP4_ADDR(&flyEhternetInfo.netmask, 255, 255, 0, 0);
IP4_ADDR(&flyEhternetInfo.gw, 192, 168, 1, 1);
netif_add(&flyEhternetInfo.netif, &flyEhternetInfo.ipaddr, &flyEhternetInfo.netmask, &flyEhternetInfo.gw, NULL, ethernetif_init, ethernet_input);
netif_set_default(&flyEhternetInfo.netif);
netif_set_up(&flyEhternetInfo.netif);
FlyEthernetCreate();
LwipTaskCreate();
EMAC_IntStart();
}
CPU_BOOLEAN BSP_OS_SemCreate (BSP_OS_SEM *p_sem,
BSP_OS_SEM_VAL sem_val,
CPU_CHAR *p_sem_name)
{
OS_EVENT *p_event;
#if (OS_EVENT_NAME_EN > 0)
CPU_INT08U err;
#endif
p_event = OSSemCreate(sem_val);
if (p_event == (OS_EVENT *)0) {
return (DEF_FAIL);
}
*p_sem = (BSP_OS_SEM)(p_event);
#if (OS_EVENT_NAME_EN > 0)
OSEventNameSet((OS_EVENT *)p_event,
(INT8U *)p_sem_name,
(INT8U *)&err);
#endif
return (DEF_OK);
}
/*
* Main
*/
int main(void) {
init_tlb();
enable_tlb();
printf("Hello from Nios II!\n");
mutex = altera_avalon_mutex_open(MUTEX_0_NAME); // Initialize the hardware mutex
mbox = OSSemCreate(0); // Initialize the message box
CriticalFunctionPointers* cp = (CriticalFunctionPointers*)SHARED_MEMORY_BASE;
// Wait for monitor to be done initialization of shared variables before retrieving their values
while(cp->init_complete == 0);
init_cpu1_isr(); // Initialize the ISR
// Set the task(only one in this example)
int arg_5 = CRITICAL_TASK_PRIORITY;
OSTaskCreateExt(preemption_task, &arg_5, &critical_task_stk[TASK_STACKSIZE - 1],
CRITICAL_TASK_PRIORITY, CRITICAL_TASK_PRIORITY,
critical_task_stk, TASK_STACKSIZE, NULL,0);
// Signal that the core has finished initializing
altera_avalon_mutex_lock(mutex, 1); // Acquire the hardware mutex
{
cp->core_ready[1] = 1;
}
altera_avalon_mutex_unlock(mutex); // Memory
// Start OS
OSStart();
return 0;
}
//*****************************************************************************
// Defines IPMI Main Task
//*****************************************************************************
void ipmi_task_main(void *args)
{
// 信号量初始化
ipmi_global.ipmi_sem = OSSemCreate(1);
// 消息队列初始化
ipmi_global.ipmi_req_que = OSQCreate(&ipmi_global.ipmi_req_que_pool[0], IPMI_MSG_QUE_SIZE);
ipmi_global.ipmi_prs_que = OSQCreate(&ipmi_global.ipmi_prs_que_pool[0], IPMI_MSG_QUE_SIZE);
ipmi_global.ipmi_rsp_que = OSQCreate(&ipmi_global.ipmi_rsp_que_pool[0], IPMI_MSG_QUE_SIZE);
ipmi_global.ipmi_msg_que = OSQCreate(&ipmi_global.ipmi_msg_que_pool[0], IPMI_MSG_QUE_SIZE);
ipmi_modules_init();
ipmi_sensors_init();
// IPMI任务
OSTaskCreate(ipmi_cmd_send_task, (void*)0, (OS_STK*)&send_task_stk[STK_SIZE-1], (INT8U)4);
OSTaskCreate(ipmi_cmd_proc_task, (void*)0, (OS_STK*)&proc_task_stk[STK_SIZE-1], (INT8U)5);
OSTaskCreate(ipmi_cmd_recv_task, (void*)0, (OS_STK*)&recv_task_stk[STK_SIZE-1], (INT8U)6);
OSTaskCreate(ipmi_msg_proc_task, (void*)0, (OS_STK*)&mesg_task_stk[STK_SIZE-1], (INT8U)7);
OSTaskCreate(ipmi_cmd_test_task, (void*)0, (OS_STK*)&test_task_stk[STK_SIZE-1], (INT8U)30);
// IPMI定时器
ipmi_timer_init();
while (1)
{
OSTimeDlyHMSM(0, 1, 0, 0);
}
}
void uart_init(INT8U uart_num)
{
UART_SFR* pUart = get_UART_SFR_base(uart_num);
// 8 bits, 1 stop bit, no parity check, RX disabled
pUart->CTRL= (C_UART_CTRL_UART_ENABLE | C_UART_CTRL_WORD_8BIT);
#ifdef UART_PIN_POS
#if UART_PIN_POS == UART_TX_IOH2__RX_IOH3
R_GPIOCTRL = 0; /*switch off ice*/
R_FUNPOS0 |= 1;
#else
R_FUNPOS0 &= ~(1);
#endif
#endif
#if _OPERATING_SYSTEM == 1
if(sw_uart_sem[uart_num] == NULL)
{
sw_uart_sem[uart_num] = OSSemCreate(1);
}
#endif
#if _OPERATING_SYSTEM != _OS_NONE // Soft Protect for critical section
sw_uart_lock(uart_num);
#endif
uart_tx_on[uart_num] = 0; // TX is disabled by software
#if _OPERATING_SYSTEM != _OS_NONE
sw_uart_unlock(uart_num);
#endif
uart_sw_fifo_init(uart_num);
vic_irq_register(VIC_UART, uart_isr); // Non vector interrupt register
vic_irq_enable(VIC_UART);
//uart_set_to_int(uart_num,UART_ENABLE); /* enable rx timeout interrupt */
}
void *SerialOS_SemCreate (CPU_INT16U cnt)
{
OS_SEM *psem;
LIB_ERR lib_err;
OS_ERR os_err;
psem = (OS_SEM *)Mem_PoolBlkGet((MEM_POOL *)&OS_SemPool,
(CPU_SIZE_T ) sizeof(OS_SEM),
(LIB_ERR *)&lib_err);
if (lib_err != LIB_MEM_ERR_NONE) {
return ((void *)0);
}
OSSemCreate((OS_SEM *)psem,
(CPU_CHAR *)0,
(OS_SEM_CTR )cnt,
(OS_ERR *)&os_err);
if (os_err != OS_ERR_NONE) {
Mem_PoolBlkFree((MEM_POOL *)&OS_SemPool,
(void *) psem,
(LIB_ERR *)&lib_err);
return ((void *)0);
}
return ((void *)psem);
}
void WatchDog(void* pdata)
{
INT8U err;
printf("WatchDog Task created! : Ticks : %d\n",(int) alt_timestamp_freq() );
Sem_WDT_Signal = OSSemCreate(0);
while(1)
{
OSSemPend(Sem_WDT_Signal, WatchDog_PERIOD, &err);
if(err == OS_ERR_NONE){
//if(DEBUG_OLD)
//printf(" OK \n");
}
else {
//printf("Pend Error\n");
if(err == OS_ERR_TIMEOUT)
printf("------ Watchdog Timer ALERT : Over Load Detected ------- : %d \n",(int) (alt_timestamp() / (alt_timestamp_freq()/1000)));
if(err == OS_ERR_PEND_LOCKED)
printf("SEM got LOCKED \n\n");
}
}
}
/*
* timerInit - Initialize the timer timer subsystem.
*/
void timerInit(void)
{
int i;
/* Initialize the timer queue sentinal. */
memset(&timerHead, 0, sizeof(Timer));
timerHead.timerNext = &timerHead;
timerHead.timerPrev = &timerHead;
timerHead.expiryTime = OSTimeGet() + MAXJIFFYDELAY;
timerHead.timerHandler = nullTimer;
/* Initialize the timer free list. */
timerFree = &timerHeap[0];
memset(timerFree, 0, sizeof(timerHeap));
for (i = 0; i < MAXFREETIMERS; i++) {
timerHeap[i].timerFlags = TIMERFLAG_TEMP;
timerHeap[i].timerNext = &timerHeap[i + 1];
}
timerHeap[MAXFREETIMERS - 1].timerNext = NULL;
/* Start the timer task. */
#ifdef OS_DEPENDENT
mutex = OSSemCreate(1);
OSTaskCreate(timerTask, NULL, timerStack+TIMER_STACK_SIZE, PRI_TIMER);
#endif
}
/*
* This function creates a semaphore.
*/
extern SEM_ID semBCreate
(
uint16_t cnt /* the initial value for the semaphore */
)
{
return OSSemCreate (cnt);
}
//开始任务
void AppStartTask(void *pdata)
{
OS_CPU_SR cpu_sr=0;
pdata = pdata;
msg_test=OSMboxCreate((void*)0); //创建消息邮箱
sem_test=OSSemCreate(0); //创建信号量
OSStatInit(); //初始化统计任务.这里会延时1秒钟左右
OS_ENTER_CRITICAL(); //进入临界区(无法被中断打断)
OSTaskCreate(AppLEDTask,(void *)0,
&APP_LED_STK[TASK_STK_SIZE-1],
APP_LED_TASK_PRIO); //建立LED1任务
OSTaskCreate(AppMBOXTask,(void *)0,
&APP_MBOX_STK[TASK_STK_SIZE-1],
APP_MBOX_TASK_PRIO); //建立邮箱接收显示任务
OSTaskCreate(AppSEMTask,(void *)0,
&APP_SEM_STK[TASK_STK_SIZE-1],
APP_SEM_TASK_PRIO); //建立信号量接收显示任务
OSTaskCreate(AppWDOGTask,(void *)0,
&APP_WDOG_STK[TASK_STK_SIZE-1],
APP_WDOG_TASK_PRIO); //建立看门狗任务
OSTaskCreate(AppPostTask,(void *)0,
&APP_POST_STK[TASK_STK_SIZE-1],
APP_POST_TASK_PRIO); //建立邮箱，信号量投递任务
UART_printf("uCOSII MBox&Sem DemoTest\r\n");
OSTaskSuspend(APP_START_TASK_PRIO); //挂起起始任务.
OS_EXIT_CRITICAL(); //退出临界区(可以被中断打断)
}
/**
\brief Same as dnm_cli_traceDump with a Mutex to prevent overlapping prints
*/
void dnm_ucli_traceDumpBlocking(BOOLEAN isTraceEnabled,
const INT8U* data, INT32S len, const char* format, ...)
{
va_list marker;
INT8U err = OS_ERR_NONE;
if (!isTraceEnabled) {
return;
}
// create mutex if not created
if (dnm_ucli_v.blockingTraceMutex == NULL) {
dnm_ucli_v.blockingTraceMutex = OSSemCreate(1);
}
// wait for mutex
OSSemPend(dnm_ucli_v.blockingTraceMutex, 0, &err);
ASSERT (err == OS_ERR_NONE);
va_start(marker, format);
dnm_ucli_dump_v(data, len, format, marker);
va_end(marker);
// release mutex
err = OSSemPost(dnm_ucli_v.blockingTraceMutex);
ASSERT (err == OS_ERR_NONE);
}
/*************************************************************************
* main()
Includes: Initialize OS, Key, and LCD
Creates start task
*************************************************************************/
void main(void)
{
DBUG_PORT = 0x00; //Initialize Debug bits
DBUG_PORT_DIR = DB_OUTS;
OSInit();
TransmitFlag = OSSemCreate(0);
ReceiveFlag = OSSemCreate(0);
(void)OSTaskCreate(StartTask, /* Create Startup Task */
(void *)0,
(void *)&StartTaskStk[STARTTASK_STK_SIZE],
STARTTASK_PRIO);
OSStart(); /* Start multitasking */
}
void CDC_Init(void)
{
uint_8 error;
g_send_size = 0;
// Create USB semaphore
if (OSSemCreate(0,&USB_Sem) != ALLOC_EVENT_OK)
{
while(1){};
};
// Cria uma fila de recepcao para a porta serial
if (OSQueueCreate(CONSOLE_BUFFER_SIZE, &USB) != ALLOC_EVENT_OK)
{
while(1){};
};
UserEnterCritical();
#if (defined _MCF51MM256_H) || (defined _MCF51JE256_H) || (defined _MCF51JE128_H)
usb_int_dis();
#endif
/* Initialize the USB interface */
SCGC2 |= SCGC2_USB_MASK; /* Enables usb clock */
error = USB_Class_CDC_Init(CONTROLLER_ID,USB_App_Callback,
NULL,USB_Notify_Callback);
//if(error != USB_OK)
/* Error initializing USB-CDC Class */
UserExitCritical();
#if (defined _MCF51MM256_H) || (defined _MCF51JE256_H) || (defined _MCF51JE128_H)
usb_int_en();
#endif
}
