Tutorial #410 – MB1225 – Hello world

/*
**  hello.c - Sample code for HyperpanelOS ================================  **
**                                                                           **
**  This simple code is located into the Application Container, it is run    **
**  by the VMK sub-operating system. On the other hand, the I/O container    **
**  runs all the drivers that are VMIO Finite State machines.                **
**                                                                           **
**  The goal of this small aplication is to write a single message           **
**  "Hello World" each second to serial port ASY0                            **
**                                                                           **
**  =======================================================================  **
*/


/* Includes files and external references ...................................*/

#include <hypos.h>                     // Hyperpanel OS basic interfaces
#include <drv_asy.h>                   // Prototype of "asy_write"


/* Internal defines of this module ------------------------------------------*/

#define  TICK                   10000  // Code for tick event
                                
                                
/* Internal global variables of this module ---------------------------------*/
 
int            dbg_test = 0          ;
unsigned int   idto                  ; // Timer identifier


/*  Prototypes --------------------------------------------------------------*/

    static int  wait_evt(void)       ; // Prototype

/* Beginning of the code ----------------------------------------------------

loop_app_tsk        Entry point for create_task - Main event loop

*/


/*  Procedure loop_app_tsk ----------------------------------------------------

    Purpose : This is our task main loop.
*/

int loop_app_tsk (void *param)
  {
    int             ev               ; // Our event
    int             cpt = 0          ; // Counter of messages
    char            mess[80]         ; // Message to be sent

/*****************************************************************************
 * Step 1 : We start a timer that will send us an event every 1 second so    *
 * ------   that we can update the time.                                     *
 *****************************************************************************/

    set_uto(CLOCK      ,               // Timer mode: clock
            1000       ,               // Duration in milliseconds
            TICK       ,               // Event code
            0          ,               // Event reserve field
            &idto        )           ; // Timer identifier


/*****************************************************************************
 * Step 2 : Here is our main event loop. For each loop, we do as follows :   *
 * -------  - First we wait for an event.                                    *
 *          - Then if the event code is TICK we print "Hello World"          *
 *****************************************************************************/

    wait_ev                          : // Beginning of loop label

    ev = wait_evt()                  ; // Unschedule until an event is
                                       // received

    if ( ev == TICK )                  // If the event is the tick event
      {                                //
        hsprintf(mess            ,     // We build in "mess" the message
           "%6d  Hello World\r\n",     // to be sent
            cpt ++                 ) ; //

        asy_write(0              ,     // We send on ASY0
            (unsigned char*)mess ,     // the "mess" message
            strlen(mess)           ) ; // Count of bytes to be sent
      }

    goto wait_ev                     ; // Wait for the next event

    return 0                         ;
  }

/*  Procedure wait_evt ------------------------------------------------------*/
/*
    Purpose : Unschedule until the next event is received, whatever it is.
*/

static int wait_evt (void)
  {
    unsigned int waitlist[1][3]      ; // Parameter of "waitevt_task"

/*****************************************************************************
 * Step 1 : Build a list with one WAIT_CODEINT entry that will accept all    *
 * ------   the event codes ranging from 0 to 20000. Then call               *
 *          "waitevt_task", we will be unscheduled until the next event will *
 *          be received                                                      *
 *****************************************************************************/

    dbg_test++                       ;

    waitlist[0][0]  = WAIT_CODEINT   ; // All events with
    waitlist[0][1]  = 0              ; // a code between 0
    waitlist[0][2]  = 20000          ; // and 20000

    waitevt_task(waitlist ,            // Address of waiting list
                 1        ,            // Size of "waitlist[]"
                 0        ,            // maximum waiting time = no
                 0        )          ; // Do not purge previous events

/*****************************************************************************
 * Step 2 : Here we are scheduled again. The VMK has written into its        *
 * ------   global variable "task_evt" a copy of the event that has          *
 *          scheduled us again.                                              *
 *****************************************************************************/

    return task_evt.code             ; // Return event code
  }