rtos.h

CANopenNode source code with tutorials - free CANopen stack

                           int initvalue);

/*************************************************************************/
//Delete a  semaphore
/*************************************************************************/
int  _cdecl RTX_Delete_Sem(int semID);

/*************************************************************************/
//Free a  resource semaphore
/*************************************************************************/
int  _cdecl RTX_Free_Sem(int semID);

/*************************************************************************/
//Get a  counting semaphore
/*************************************************************************/
int  _cdecl RTX_Get_Sem(int semID);

/*************************************************************************/
//Release a  resoure semaphore
/*************************************************************************/
int  _cdecl RTX_Release_Sem(int semID);

/*************************************************************************/
//Reserve a  resoure semaphore (optional timeout)
/*************************************************************************/
int  _cdecl RTX_Reserve_Sem(int semID, long   far  * time_ms);

/*************************************************************************/
//Signal a  counting semaphore
/*************************************************************************/
int  _cdecl RTX_Signal_Sem(int semID);

/*************************************************************************/
//Wait on a  counting semaphore (optional timeout)
/*************************************************************************/
int  _cdecl RTX_Wait_Sem(int semID, long  far  *time_ms);

/*************************************************************************/
//Find an semaphore, specified by 4 char name tag
/*************************************************************************/
int  _cdecl RTX_Find_Sem(int far *ID, char far *name);

/*************************************************************************/
//Get system time and date
/*************************************************************************/
int  _cdecl RTX_Get_TimeDate(TimeDate_Structure  far  * td);

/*************************************************************************/
//Set system time and date
/*************************************************************************/
int  _cdecl RTX_Set_TimeDate(TimeDate_Structure  far  * td);

/*************************************************************************/
//Set system ticks
/*************************************************************************/
void _cdecl RTX_Get_System_Ticks(unsigned long far * ticks);

/*************************************************************************/
//Install timer procedure
/*************************************************************************/
int  _cdecl RTX_Install_Timer (const TimerProc_Structure far * TProcPtr) ;

/*************************************************************************/
// Alternate timer procedure install method, using explicit
//   parameters, equivalent to RTX_Install_Timer().
/*************************************************************************/

int  _cdecl RTX_Install_TimerP (unsigned int  far  *timerID, 
                                RTX_TIMER_CALLBACK  proc,
                                unsigned long       lParam, 
                                unsigned long       name,
                                long                interval) ;

/*************************************************************************/
// Remove timer procedure
/*************************************************************************/
int  _cdecl RTX_Remove_Timer(unsigned int timerID);

/*************************************************************************/
// Start periodic execution of timer procedure
/*************************************************************************/
int  _cdecl RTX_Start_Timer(unsigned int timerID);

/*************************************************************************/
// Stop periodic execution of timer procedure
/*************************************************************************/
int  _cdecl RTX_Stop_Timer(unsigned int timerID);

/*************************************************************************/
// Create event group
/*************************************************************************/
int  _cdecl RTX_Create_EventGroup (unsigned int far *id_ptr, 
                                   const char   far *name, 
                                   unsigned int init_value) ;

/*************************************************************************/
// Delete an event group
/*************************************************************************/
int  _cdecl RTX_Delete_EventGroup(unsigned int id);

/*************************************************************************/
// Signal events group
/*************************************************************************/
int  _cdecl RTX_Signal_Events (unsigned int id, 
                               unsigned int event_mask, 
                               unsigned int event_value) ;

/*************************************************************************/
// Wait for events
/*************************************************************************/
int  _cdecl RTX_Wait_For_Event (unsigned int id, 
                                const RTX_Wait_Event far * event_ptr) ;

// Alternative method, using explicit parameters
int  _cdecl RTX_Wait_For_EventP (unsigned int id,    unsigned int mask,  
                                 unsigned int value, int match, long timeout) ;

/*************************************************************************/
// Read current events on a group
/*************************************************************************/
int  _cdecl RTX_Get_EventGroup_State (unsigned int id, 
                                      unsigned int far * event) ;

/*************************************************************************/
// Get the saved event flags/bits
/*************************************************************************/
int  _cdecl RTX_Get_Saved_Events(unsigned int far *Event);

/*************************************************************************/
//Find an event group, specified by 4 char name tag
/*************************************************************************/
int  _cdecl RTX_Find_EventGroup(unsigned int far * id_ptr, 
                                const char far * name);

/*************************************************************************/
//Create message exchange
/*************************************************************************/
int  _cdecl RTX_Create_Msg(RTX_Msg far * msg_ptr);

/*************************************************************************/
//Delete a message exchange
/*************************************************************************/
int  _cdecl RTX_Delete_Msg(unsigned int id);

/*************************************************************************/
//Send a message to a message exchange
/*************************************************************************/
int  _cdecl RTX_Send_Msg(unsigned int id, int prio, const void far * msg);

/*************************************************************************/
//Get a message from a message exchange, no wait
/*************************************************************************/
int  _cdecl RTX_Get_Msg(unsigned int id, void far * msg);

/*************************************************************************/
//Wait for a message, optional timeout
/*************************************************************************/
int  _cdecl RTX_Wait_For_Msg (const RTX_Wait_Msg far * msg_ptr);

// Alternate method, with direct parameters
int  _cdecl RTX_Wait_For_MsgP (unsigned int msgID, unsigned int prio,
                               void far *msg, long timeout);

/*************************************************************************/
//Find an message exchange, specified by 4 char name tag
/*************************************************************************/
int  _cdecl RTX_Find_Msg(unsigned int far * id_ptr, const char far * name);

#ifdef __cplusplus
}
#endif

/*************************************************************************/
#endif /* _RTOS_H___ */
/*************************************************************************/
//end rtos.h